Enum Stmt 

pub enum Stmt {
    Let {
        name: Ident,
        ty: Option<TypeExpr>,
        value: Expr,
        span: Span,
    },
    Assign {
        name: Ident,
        value: Expr,
        span: Span,
    },
    Return {
        value: Option<Expr>,
        span: Span,
    },
    If {
        condition: Expr,
        then_block: Block,
        else_block: Option<ElseBranch>,
        span: Span,
    },
    For {
        pattern: Pattern,
        iter: Expr,
        body: Block,
        span: Span,
    },
    While {
        condition: Expr,
        body: Block,
        span: Span,
    },
    Loop {
        body: Block,
        span: Span,
    },
    Break {
        span: Span,
    },
    SpanBlock {
        name: Expr,
        body: Block,
        span: Span,
    },
    Checkpoint {
        span: Span,
    },
    Expr {
        expr: Expr,
        span: Span,
    },
    LetTuple {
        names: Vec<Ident>,
        ty: Option<TypeExpr>,
        value: Expr,
        span: Span,
    },
    MockDivine {
        value: MockValue,
        span: Span,
    },
    MockTool {
        tool_name: Ident,
        fn_name: Ident,
        value: MockValue,
        span: Span,
    },
}

A statement.

Variants

Let

Variable binding: let name: Type = expr or let name = expr

Fields

name: Ident

The variable name.

ty: Option<TypeExpr>

Optional type annotation.

value: Expr

The initial value.

span: Span

Span covering the statement.

Assign

Assignment: name = expr

Fields

name: Ident

The variable being assigned to.

value: Expr

The new value.

span: Span

Span covering the statement.

Return

Return statement: return expr?

Fields

value: Option<Expr>

The optional return value.

span: Span

Span covering the statement.

If

If statement: if cond { ... } else { ... }

Fields

condition: Expr

The condition (must be Bool).

then_block: Block

The then branch.

else_block: Option<ElseBranch>

The optional else branch (can be another If for else-if chains).

span: Span

Span covering the statement.

For

For loop: for x in iter { ... } or for (k, v) in map { ... }

Fields

pattern: Pattern

The loop pattern (can be a simple binding or tuple destructuring).

iter: Expr

The iterable expression (List or Map<K, V>).

body: Block

The loop body.

span: Span

Span covering the statement.

While

While loop: while cond { ... }

Fields

condition: Expr

The condition (must be Bool).

body: Block

The loop body.

span: Span

Span covering the statement.

Loop

Infinite loop: loop { ... }

Fields

body: Block

The loop body.

span: Span

Span covering the statement.

Break

Break statement: break

Fields

span: Span

Span covering the statement.

SpanBlock

Span block: span "name" { body } for timed observability blocks. Records start/end times and emits trace events.

Fields

name: Expr

The span name (should be a string literal or expression).

body: Block

The block body.

span: Span

Span covering the statement.

Checkpoint

Explicit checkpoint statement: checkpoint(); Forces an immediate checkpoint of all @persistent beliefs. Only valid inside agent handler bodies.

Fields

span: Span

Span covering the statement.

Expr

Expression statement: expr

Fields

expr: Expr

The expression.

span: Span

Span covering the statement.

LetTuple

Tuple destructuring: let (a, b) = expr;

Fields

names: Vec<Ident>

The variable names.

ty: Option<TypeExpr>

Optional type annotation.

value: Expr

The value expression.

span: Span

Span covering the statement.

MockDivine

RFC-0012: Mock divine statement: mock divine -> expr;

Fields

value: MockValue

The mock value expression.

span: Span

Span covering the statement.

MockTool

Mock tool statement: mock tool Http.get -> value;

Fields

tool_name: Ident

The tool name.

fn_name: Ident

The function name.

value: MockValue

The mock value expression.

span: Span

Span covering the statement.

Implementations

impl Stmt

pub fn span(&self) -> &Span

Get the span of this statement.

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Stmt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Stmt

fn eq(&self, other: &Stmt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Stmt