Enum Expr 

pub enum Expr {
    Literal(Literal),
    Path(TypePath),
    Binary {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    Pipe {
        expr: Box<Expr>,
        operations: Vec<PipeOp>,
    },
    Incorporation {
        segments: Vec<IncorporationSegment>,
    },
    Morpheme {
        kind: MorphemeKind,
        body: Box<Expr>,
    },
    Call {
        func: Box<Expr>,
        args: Vec<Expr>,
    },
    MethodCall {
        receiver: Box<Expr>,
        method: Ident,
        type_args: Option<Vec<TypeExpr>>,
        args: Vec<Expr>,
    },
    Field {
        expr: Box<Expr>,
        field: Ident,
    },
    Index {
        expr: Box<Expr>,
        index: Box<Expr>,
    },
    Array(Vec<Expr>),
    ArrayRepeat {
        value: Box<Expr>,
        count: Box<Expr>,
    },
    Tuple(Vec<Expr>),
    Struct {
        path: TypePath,
        fields: Vec<FieldInit>,
        rest: Option<Box<Expr>>,
    },
    Block(Block),
    If {
        condition: Box<Expr>,
        then_branch: Block,
        else_branch: Option<Box<Expr>>,
    },
    Match {
        expr: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Loop {
        label: Option<Ident>,
        body: Block,
    },
    While {
        label: Option<Ident>,
        condition: Box<Expr>,
        body: Block,
    },
    For {
        label: Option<Ident>,
        pattern: Pattern,
        iter: Box<Expr>,
        body: Block,
    },
    Closure {
        params: Vec<ClosureParam>,
        return_type: Option<TypeExpr>,
        body: Box<Expr>,
        is_move: bool,
    },
    Await {
        expr: Box<Expr>,
        evidentiality: Option<Evidentiality>,
    },
    Try(Box<Expr>),
    Return(Option<Box<Expr>>),
    Break {
        label: Option<Ident>,
        value: Option<Box<Expr>>,
    },
    Continue {
        label: Option<Ident>,
    },
    Range {
        start: Option<Box<Expr>>,
        end: Option<Box<Expr>>,
        inclusive: bool,
    },
    Macro {
        path: TypePath,
        tokens: String,
    },
    Evidential {
        expr: Box<Expr>,
        evidentiality: Evidentiality,
    },
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
    },
    Let {
        pattern: Pattern,
        value: Box<Expr>,
    },
    Unsafe(Block),
    Async {
        block: Block,
        is_move: bool,
    },
    Deref(Box<Expr>),
    AddrOf {
        mutable: bool,
        expr: Box<Expr>,
    },
    Cast {
        expr: Box<Expr>,
        ty: TypeExpr,
    },
    InlineAsm(InlineAsm),
    VolatileRead {
        ptr: Box<Expr>,
        ty: Option<TypeExpr>,
    },
    VolatileWrite {
        ptr: Box<Expr>,
        value: Box<Expr>,
        ty: Option<TypeExpr>,
    },
    SimdLiteral {
        elements: Vec<Expr>,
        ty: Option<TypeExpr>,
    },
    SimdIntrinsic {
        op: SimdOp,
        args: Vec<Expr>,
    },
    SimdShuffle {
        a: Box<Expr>,
        b: Box<Expr>,
        indices: Vec<u8>,
    },
    SimdSplat {
        value: Box<Expr>,
        lanes: u8,
    },
    SimdExtract {
        vector: Box<Expr>,
        index: u8,
    },
    SimdInsert {
        vector: Box<Expr>,
        index: u8,
        value: Box<Expr>,
    },
    AtomicOp {
        op: AtomicOp,
        ptr: Box<Expr>,
        value: Option<Box<Expr>>,
        expected: Option<Box<Expr>>,
        ordering: MemoryOrdering,
        failure_ordering: Option<MemoryOrdering>,
    },
    AtomicFence {
        ordering: MemoryOrdering,
    },
    HttpRequest {
        method: HttpMethod,
        url: Box<Expr>,
        headers: Vec<(Expr, Expr)>,
        body: Option<Box<Expr>>,
        timeout: Option<Box<Expr>>,
    },
    GrpcCall {
        service: Box<Expr>,
        method: Box<Expr>,
        message: Option<Box<Expr>>,
        metadata: Vec<(Expr, Expr)>,
        timeout: Option<Box<Expr>>,
    },
    WebSocketConnect {
        url: Box<Expr>,
        protocols: Vec<Expr>,
        headers: Vec<(Expr, Expr)>,
    },
    WebSocketMessage {
        kind: WebSocketMessageKind,
        data: Box<Expr>,
    },
    KafkaOp {
        kind: KafkaOpKind,
        topic: Box<Expr>,
        payload: Option<Box<Expr>>,
        key: Option<Box<Expr>>,
        partition: Option<Box<Expr>>,
    },
    GraphQLOp {
        kind: GraphQLOpKind,
        document: Box<Expr>,
        variables: Option<Box<Expr>>,
        operation_name: Option<Box<Expr>>,
    },
    ProtocolStream {
        protocol: ProtocolKind,
        source: Box<Expr>,
        config: Option<Box<Expr>>,
    },
    LegionFieldVar {
        name: Ident,
    },
    LegionSuperposition {
        field: Box<Expr>,
        pattern: Box<Expr>,
    },
    LegionInterference {
        query: Box<Expr>,
        field: Box<Expr>,
    },
    LegionResonance {
        expr: Box<Expr>,
    },
    LegionDistribute {
        task: Box<Expr>,
        count: Box<Expr>,
    },
    LegionGather {
        fragments: Box<Expr>,
    },
    LegionBroadcast {
        signal: Box<Expr>,
        target: Box<Expr>,
    },
    LegionConsensus {
        contributions: Box<Expr>,
    },
    LegionDecay {
        field: Box<Expr>,
        rate: Box<Expr>,
    },
    NamedArg {
        name: Ident,
        value: Box<Expr>,
    },
}

Expressions.

Variants

Literal(Literal)

Literal value

Path(TypePath)

Variable reference

Binary

Binary operation

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

Unary

Unary operation

Fields

op: UnaryOp

expr: Box<Expr>

Pipe

Pipe expression: x|f|g

Fields

expr: Box<Expr>

operations: Vec<PipeOp>

Incorporation

Incorporation: file·open·read

Fields

segments: Vec<IncorporationSegment>

Morpheme

Morpheme application: τ{f}

Fields

kind: MorphemeKind

body: Box<Expr>

Call

Function call

Fields

func: Box<Expr>

args: Vec<Expr>

MethodCall

Method call

Fields

receiver: Box<Expr>

method: Ident

type_args: Option<Vec<TypeExpr>>

Turbofish type arguments: method::<T, U>(args)

args: Vec<Expr>

Field

Field access

Fields

expr: Box<Expr>

field: Ident

Index

Index: arr[i]

Fields

expr: Box<Expr>

index: Box<Expr>

Array(Vec<Expr>)

Array literal

ArrayRepeat

Array repeat literal: [value; count]

Fields

value: Box<Expr>

count: Box<Expr>

Tuple(Vec<Expr>)

Tuple literal

Struct

Struct literal

Fields

path: TypePath

fields: Vec<FieldInit>

rest: Option<Box<Expr>>

Block(Block)

Block expression

If

If expression

Fields

condition: Box<Expr>

then_branch: Block

else_branch: Option<Box<Expr>>

Match

Match expression

Fields

expr: Box<Expr>

arms: Vec<MatchArm>

Loop

Loop with optional label: 'label: loop { ... }

Fields

label: Option<Ident>

body: Block

While

While loop with optional label: 'label: while cond { ... }

Fields

label: Option<Ident>

condition: Box<Expr>

body: Block

For

For loop with optional label: 'label: for x in iter { ... }

Fields

label: Option<Ident>

pattern: Pattern

iter: Box<Expr>

body: Block

Closure

Closure: {x => x + 1} or |x| x + 1 or move |x| x + 1 or |x| -> T { ... }

Fields

params: Vec<ClosureParam>

return_type: Option<TypeExpr>

Optional explicit return type annotation: |x| -> i32 { x + 1 }

body: Box<Expr>

is_move: bool

Whether this is a move closure that takes ownership of captured variables

Await

Await with optional evidentiality: expr⌛ or expr⌛? or expr⌛! or expr⌛~ The evidentiality marker specifies how to handle the awaited result:

• ⌛? - await and propagate error (uncertain)
• ⌛! - await, expect success (known/infallible)
• ⌛~ - await external/reported source
• ⌛‽ - await with trust boundary crossing

Fields

expr: Box<Expr>

evidentiality: Option<Evidentiality>

Try(Box<Expr>)

Try: expr?

Return(Option<Box<Expr>>)

Return

Break

Break with optional label and value: break 'label value

Fields

label: Option<Ident>

value: Option<Box<Expr>>

Continue

Continue with optional label: continue 'label

Fields

label: Option<Ident>

Range

Range: a..b or a..=b

Fields

start: Option<Box<Expr>>

end: Option<Box<Expr>>

inclusive: bool

Macro

Macro invocation

Fields

path: TypePath

tokens: String

Evidential

With evidentiality marker

Fields

expr: Box<Expr>

evidentiality: Evidentiality

Assign

Assignment: x = value

Fields

target: Box<Expr>

value: Box<Expr>

Let

Let expression (for if-let, while-let patterns): let pattern = expr

Fields

pattern: Pattern

value: Box<Expr>

Unsafe(Block)

Unsafe block: unsafe { ... }

Async

Async block: async { ... } or async move { ... }

Fields

block: Block

is_move: bool

Deref(Box<Expr>)

Raw pointer dereference: *ptr

AddrOf

Address-of: &expr or &mut expr

Fields

mutable: bool

expr: Box<Expr>

Cast

Cast: expr as Type

Fields

expr: Box<Expr>

ty: TypeExpr

InlineAsm(InlineAsm)

Inline assembly: asm!("instruction", ...)

VolatileRead

Volatile read: volatile read<T>(ptr) or volatile read(ptr)

Fields

ptr: Box<Expr>

ty: Option<TypeExpr>

VolatileWrite

Volatile write: volatile write<T>(ptr, value) or volatile write(ptr, value)

Fields

ptr: Box<Expr>

value: Box<Expr>

ty: Option<TypeExpr>

SimdLiteral

SIMD vector literal: simd[1.0, 2.0, 3.0, 4.0]

Fields

elements: Vec<Expr>

ty: Option<TypeExpr>

SimdIntrinsic

SIMD intrinsic operation: simd::add(a, b)

Fields

op: SimdOp

args: Vec<Expr>

SimdShuffle

SIMD shuffle: simd::shuffle(a, b, [0, 4, 1, 5])

Fields

a: Box<Expr>

b: Box<Expr>

indices: Vec<u8>

SimdSplat

SIMD splat (broadcast scalar to all lanes): simd::splat(x)

Fields

value: Box<Expr>

lanes: u8

SimdExtract

SIMD extract single lane: simd::extract(v, 0)

Fields

vector: Box<Expr>

index: u8

SimdInsert

SIMD insert into lane: simd::insert(v, 0, value)

Fields

vector: Box<Expr>

index: u8

value: Box<Expr>

AtomicOp

Atomic operation: atomic::load(&x, Ordering::SeqCst)

Fields

op: AtomicOp

ptr: Box<Expr>

value: Option<Box<Expr>>

expected: Option<Box<Expr>>

ordering: MemoryOrdering

failure_ordering: Option<MemoryOrdering>

AtomicFence

Atomic fence: atomic::fence(Ordering::SeqCst)

Fields

ordering: MemoryOrdering

HttpRequest

HTTP request: http·get(url), http·post(url), etc. Incorporation pattern for building HTTP requests

Fields

method: HttpMethod

url: Box<Expr>

headers: Vec<(Expr, Expr)>

body: Option<Box<Expr>>

timeout: Option<Box<Expr>>

GrpcCall

gRPC call: grpc·call(service, method) Incorporation pattern for gRPC operations

Fields

service: Box<Expr>

method: Box<Expr>

message: Option<Box<Expr>>

metadata: Vec<(Expr, Expr)>

timeout: Option<Box<Expr>>

WebSocketConnect

WebSocket connection: ws·connect(url) Incorporation pattern for WebSocket operations

Fields

url: Box<Expr>

protocols: Vec<Expr>

headers: Vec<(Expr, Expr)>

WebSocketMessage

WebSocket message: ws·message(data) or ws·text(str) / ws·binary(bytes)

Fields

kind: WebSocketMessageKind

data: Box<Expr>

KafkaOp

Kafka operation: kafka·produce(topic, message), kafka·consume(topic)

Fields

kind: KafkaOpKind

topic: Box<Expr>

payload: Option<Box<Expr>>

key: Option<Box<Expr>>

partition: Option<Box<Expr>>

GraphQLOp

GraphQL query: graphql·query(document) or graphql·mutation(document)

Fields

kind: GraphQLOpKind

document: Box<Expr>

variables: Option<Box<Expr>>

operation_name: Option<Box<Expr>>

ProtocolStream

Protocol stream: iterable over network messages http·stream(url), ws·stream(), kafka·stream(topic)

Fields

protocol: ProtocolKind

source: Box<Expr>

config: Option<Box<Expr>>

LegionFieldVar

Legion field variable: memory∿ The ∿ suffix indicates a LegionField collective memory type

Fields

name: Ident

LegionSuperposition

Superposition: field∿ ⊕= pattern Pattern joins the collective memory

Fields

field: Box<Expr>

pattern: Box<Expr>

LegionInterference

Interference query: query ⫰ field∿ Query the collective memory via interference

Fields

query: Box<Expr>

field: Box<Expr>

LegionResonance

Resonance extraction: resonance~ |◉ Extract agreement peaks from interference pattern

Fields

expr: Box<Expr>

LegionDistribute

Distribute: task ⟁ agent_count Fragment task holographically across agents

Fields

task: Box<Expr>

count: Box<Expr>

LegionGather

Gather: fragments ⟀ Unify fragments via interference

Fields

fragments: Box<Expr>

LegionBroadcast

Broadcast: signal ↠ legion Send signal to all agents

Fields

signal: Box<Expr>

target: Box<Expr>

LegionConsensus

Consensus: contributions ⇢ Achieve consensus from multiple contributions

Fields

contributions: Box<Expr>

LegionDecay

Decay: field∿ ∂= rate Apply decay to collective memory

Fields

field: Box<Expr>

rate: Box<Expr>

NamedArg

Named argument in function call: name: value Used in calls like stack(axis: 0) or func(x: 1, y: 2)

Fields

name: Ident

value: Box<Expr>

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