Enum Expr 

pub enum Expr {
    Divine {
        template: StringTemplate,
        result_ty: Option<TypeExpr>,
        span: Span,
    },
    Summon {
        agent: Ident,
        fields: Vec<FieldInit>,
        span: Span,
    },
    Await {
        handle: Box<Expr>,
        timeout: Option<Box<Expr>>,
        span: Span,
    },
    Send {
        handle: Box<Expr>,
        message: Box<Expr>,
        span: Span,
    },
    Yield {
        value: Box<Expr>,
        span: Span,
    },
    Call {
        name: Ident,
        type_args: Vec<TypeExpr>,
        args: Vec<Expr>,
        span: Span,
    },
    Apply {
        callee: Box<Expr>,
        args: Vec<Expr>,
        span: Span,
    },
    SelfMethodCall {
        method: Ident,
        args: Vec<Expr>,
        span: Span,
    },
    SelfField {
        field: Ident,
        span: Span,
    },
    Binary {
        op: BinOp,
        left: Box<Expr>,
        right: Box<Expr>,
        span: Span,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expr>,
        span: Span,
    },
    List {
        elements: Vec<Expr>,
        span: Span,
    },
    Literal {
        value: Literal,
        span: Span,
    },
    Var {
        name: Ident,
        span: Span,
    },
    Paren {
        inner: Box<Expr>,
        span: Span,
    },
    StringInterp {
        template: StringTemplate,
        span: Span,
    },
    Match {
        scrutinee: Box<Expr>,
        arms: Vec<MatchArm>,
        span: Span,
    },
    RecordConstruct {
        name: Ident,
        type_args: Vec<TypeExpr>,
        fields: Vec<FieldInit>,
        span: Span,
    },
    FieldAccess {
        object: Box<Expr>,
        field: Ident,
        span: Span,
    },
    Receive {
        span: Span,
    },
    Try {
        expr: Box<Expr>,
        span: Span,
    },
    Catch {
        expr: Box<Expr>,
        error_bind: Option<Ident>,
        recovery: Box<Expr>,
        span: Span,
    },
    Fail {
        error: Box<Expr>,
        span: Span,
    },
    Retry {
        count: Box<Expr>,
        delay: Option<Box<Expr>>,
        on_errors: Option<Vec<Expr>>,
        body: Box<Expr>,
        span: Span,
    },
    Trace {
        message: Box<Expr>,
        span: Span,
    },
    Closure {
        params: Vec<ClosureParam>,
        body: Box<Expr>,
        span: Span,
    },
    Tuple {
        elements: Vec<Expr>,
        span: Span,
    },
    TupleIndex {
        tuple: Box<Expr>,
        index: usize,
        span: Span,
    },
    Map {
        entries: Vec<MapEntry>,
        span: Span,
    },
    VariantConstruct {
        enum_name: Ident,
        type_args: Vec<TypeExpr>,
        variant: Ident,
        payload: Option<Box<Expr>>,
        span: Span,
    },
    ToolCall {
        tool: Ident,
        function: Ident,
        args: Vec<Expr>,
        span: Span,
    },
    Reply {
        message: Box<Expr>,
        span: Span,
    },
}

An expression.

Variants

Divine

LLM divination: divine("template") or divine("template" -> Type)

Fields

template: StringTemplate

The prompt template (may contain {ident} interpolations).

result_ty: Option<TypeExpr>

Optional result type annotation.

span: Span

Span covering the expression.

Summon

Agent summoning: summon AgentName { field: value, ... }

Fields

agent: Ident

The agent type to spawn.

fields: Vec<FieldInit>

Initial belief values.

span: Span

Span covering the expression.

Await

Await: await expr or await expr timeout(ms)

Fields

handle: Box<Expr>

The agent handle to await.

timeout: Option<Box<Expr>>

Optional timeout in milliseconds.

span: Span

Span covering the expression.

Send

Send message: send(handle, message)

Fields

handle: Box<Expr>

The agent handle to send to.

message: Box<Expr>

The message to send.

span: Span

Span covering the expression.

Yield

Yield value: yield(value)

Fields

value: Box<Expr>

The value to emit to the awaiter.

span: Span

Span covering the expression.

Call

Function call: name(args) or name::<T, U>(args) (turbofish)

Fields

name: Ident

The function name.

type_args: Vec<TypeExpr>

Explicit type arguments (turbofish syntax): foo::<Int, String>(...)

args: Vec<Expr>

The arguments.

span: Span

Span covering the expression.

Apply

Apply expression: call an arbitrary expression as a function. Used for method calls on values: expr.method(args) becomes Apply { callee: FieldAccess { object: expr, field: method }, args }

Fields

callee: Box<Expr>

The expression being called (typically a FieldAccess for method calls).

args: Vec<Expr>

The arguments.

span: Span

Span covering the expression.

SelfMethodCall

Method call on self: self.method(args)

Fields

method: Ident

The method name.

args: Vec<Expr>

The arguments.

span: Span

Span covering the expression.

SelfField

Self field access: self.field

Fields

field: Ident

The field (belief) name.

span: Span

Span covering the expression.

Binary

Binary operation: left op right

Fields

op: BinOp

The operator.

left: Box<Expr>

The left operand.

right: Box<Expr>

The right operand.

span: Span

Span covering the expression.

Unary

Unary operation: op operand

Fields

op: UnaryOp

The operator.

operand: Box<Expr>

The operand.

span: Span

Span covering the expression.

List

List literal: [a, b, c]

Fields

elements: Vec<Expr>

The list elements.

span: Span

Span covering the expression.

Literal

Literal value.

Fields

value: Literal

The literal value.

span: Span

Span covering the expression.

Var

Variable reference.

Fields

name: Ident

The variable name.

span: Span

Span covering the expression.

Paren

Parenthesized expression: (expr)

Fields

inner: Box<Expr>

The inner expression.

span: Span

Span covering the expression (including parens).

StringInterp

Interpolated string: "Hello, {name}!"

Fields

template: StringTemplate

The string template with interpolations.

span: Span

Span covering the expression.

Match

Match expression: match expr { Pattern => expr, ... }

Fields

scrutinee: Box<Expr>

The scrutinee expression.

arms: Vec<MatchArm>

The match arms.

span: Span

Span covering the expression.

RecordConstruct

Record construction: Point { x: 1, y: 2 } or Pair::<Int, String> { first: 1, second: "hi" }

Fields

name: Ident

The record type name.

type_args: Vec<TypeExpr>

Explicit type arguments (turbofish syntax): Pair::<Int, String> { ... }

fields: Vec<FieldInit>

Field initializations.

span: Span

Span covering the expression.

FieldAccess

Field access: record.field

Fields

object: Box<Expr>

The record expression.

field: Ident

The field name.

span: Span

Span covering the expression.

Receive

Receive message from mailbox: receive()

Fields

span: Span

Span covering the expression.

Try

Try expression: try expr — propagates failure upward.

Fields

expr: Box<Expr>

The expression that may fail.

span: Span

Span covering the expression.

Catch

Catch expression: expr catch { recovery } or expr catch(e) { recovery }.

Fields

expr: Box<Expr>

The expression that may fail.

error_bind: Option<Ident>

The optional error binding (e.g., e in catch(e)).

recovery: Box<Expr>

The recovery expression.

span: Span

Span covering the expression.

Fail

Fail expression: fail "message" or fail Error { ... }. Type is Never - this expression never returns.

Fields

error: Box<Expr>

The error value (either a string message or an Error record).

span: Span

Span covering the expression.

Retry

Retry expression: retry(3) { ... } or retry(3, delay: 1000) { ... }

Fields

count: Box<Expr>

Number of retry attempts (1-10).

delay: Option<Box<Expr>>

Optional delay between attempts in milliseconds.

on_errors: Option<Vec<Expr>>

Optional list of error kinds to retry on.

body: Box<Expr>

The body to retry.

span: Span

Span covering the expression.

Trace

Trace expression: trace("message") for emitting trace events.

Fields

message: Box<Expr>

The message to trace (must be a string).

span: Span

Span covering the expression.

Closure

Closure expression: |params| body

Fields

params: Vec<ClosureParam>

The closure parameters.

body: Box<Expr>

The closure body (single expression).

span: Span

Span covering the expression.

Tuple

Tuple literal: (a, b, c)

Fields

elements: Vec<Expr>

The tuple elements (at least 2).

span: Span

Span covering the expression.

TupleIndex

Tuple index access: tuple.0

Fields

tuple: Box<Expr>

The tuple expression.

index: usize

The index (0-based).

span: Span

Span covering the expression.

Map

Map literal: { key: value, ... } or {}

Fields

entries: Vec<MapEntry>

The map entries.

span: Span

Span covering the expression.

VariantConstruct

Enum variant construction: MyEnum.Variant or Either::<L, R>.Left(payload)

Fields

enum_name: Ident

The enum type name.

type_args: Vec<TypeExpr>

Explicit type arguments (turbofish syntax): Either::<L, R>.Left(...)

variant: Ident

The variant name.

payload: Option<Box<Expr>>

The optional payload expression.

span: Span

Span covering the expression.

ToolCall

Tool function call (RFC-0011): Http.get(url)

Fields

tool: Ident

The tool name.

function: Ident

The function name.

args: Vec<Expr>

The arguments.

span: Span

Span covering the expression.

Reply

Reply to current message (Phase 3 session types): reply(message)

Only valid inside on message handlers when the agent follows a protocol.

Fields

message: Box<Expr>

The message to send back.

span: Span

Span covering the expression.

Implementations

impl Expr

pub fn span(&self) -> &Span

Get the span of this expression.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> 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 Expr