Enum ExprKind 

pub enum ExprKind {
    Number(String),
    String(String),
    TemplateLiteral(Vec<TemplatePart>),
    Bool(bool),
    Identifier(String),
    Placeholder,
    Binary {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expr>,
    },
    Pipe {
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Unwrap(Box<Expr>),
    Call {
        callee: Box<Expr>,
        type_args: Vec<TypeExpr>,
        args: Vec<Arg>,
    },
    Construct {
        type_name: String,
        spread: Option<Box<Expr>>,
        args: Vec<Arg>,
    },
    Member {
        object: Box<Expr>,
        field: String,
    },
    Index {
        object: Box<Expr>,
        index: Box<Expr>,
    },
    Arrow {
        async_fn: bool,
        params: Vec<Param>,
        body: Box<Expr>,
    },
    Match {
        subject: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Await(Box<Expr>),
    Try(Box<Expr>),
    Ok(Box<Expr>),
    Err(Box<Expr>),
    Some(Box<Expr>),
    None,
    Value(Box<Expr>),
    Clear,
    Unchanged,
    Parse {
        type_arg: TypeExpr,
        value: Box<Expr>,
    },
    Mock {
        type_arg: TypeExpr,
        overrides: Vec<Arg>,
    },
    Todo,
    Unreachable,
    Unit,
    Jsx(JsxElement),
    Block(Vec<Item>),
    Collect(Vec<Item>),
    Grouped(Box<Expr>),
    Array(Vec<Expr>),
    Object(Vec<(String, Expr)>),
    Tuple(Vec<Expr>),
    Spread(Box<Expr>),
    DotShorthand {
        field: String,
        predicate: Option<(BinOp, Box<Expr>)>,
    },
}

Variants

Number(String)

Number literal: 42, 3.14

String(String)

String literal: "hello"

TemplateLiteral(Vec<TemplatePart>)

Template literal: `hello ${name}`

Bool(bool)

Boolean literal: true, false

Identifier(String)

Variable/function reference: x, myFunc

Placeholder

Placeholder for partial application: _

Binary

Binary operation: a + b, a == b, a && b

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

Unary

Unary operation: !x, -x

Fields

op: UnaryOp

operand: Box<Expr>

Pipe

Pipe: a |> f(b)

Fields

left: Box<Expr>

right: Box<Expr>

Unwrap(Box<Expr>)

Unwrap: expr?

Call

Function call: f(a, b, name: c) or f<T>(a, b)

Fields

callee: Box<Expr>

type_args: Vec<TypeExpr>

args: Vec<Arg>

Construct

Type constructor: User(name: "Ryan", email: e) or User(..existing, name: "New")

Fields

type_name: String

spread: Option<Box<Expr>>

args: Vec<Arg>

Member

Member access: a.b

Fields

object: Box<Expr>

field: String

Index

Index access: a[0]

Fields

object: Box<Expr>

index: Box<Expr>

Arrow

Arrow function: |a, b| a + b or async |a, b| a + b

Fields

async_fn: bool

params: Vec<Param>

body: Box<Expr>

Match

Match expression: match x { Pat -> expr, ... }

Fields

subject: Box<Expr>

arms: Vec<MatchArm>

Await(Box<Expr>)

Await: await expr

Try(Box<Expr>)

Try: try expr — wraps a throwing expression in Result

Ok(Box<Expr>)

Ok(expr)

Err(Box<Expr>)

Err(expr)

Some(Box<Expr>)

Some(expr)

None

None

Value(Box<Expr>)

Value(expr) — Settable value present

Clear

Clear — Settable value explicitly null

Unchanged

Unchanged — Settable value omitted

Parse

parse<T>(value) — compiler built-in for runtime type validation

Fields

type_arg: TypeExpr

value: Box<Expr>

Mock

mock<T> — compiler built-in for auto-generating test data from types Optional overrides: mock<User>(name: "Alice")

Fields

type_arg: TypeExpr

overrides: Vec<Arg>

Todo

todo — placeholder that panics at runtime, type never

Unreachable

unreachable — asserts unreachable code path, type never

Unit

Unit value: ()

Jsx(JsxElement)

JSX element: <Component prop={value}>children</Component>

Block(Vec<Item>)

Block expression: { stmt1; stmt2; expr }

Collect(Vec<Item>)

Collect block: collect { ... } — accumulates errors from ? instead of short-circuiting

Grouped(Box<Expr>)

Parenthesized expression: (a + b)

Array(Vec<Expr>)

Array literal: [1, 2, 3]

Object(Vec<(String, Expr)>)

Object literal: { name: "Alice", age: 30 } Fields are (key, value) pairs. Shorthand { name } desugars to { name: name }.

Tuple(Vec<Expr>)

Tuple literal: (1, 2), ("key", 42, true)

Spread(Box<Expr>)

Spread: ...expr

DotShorthand

Dot shorthand: .field or .field op expr — creates an implicit lambda

Fields

field: String

The field name (e.g., done in .done)

predicate: Option<(BinOp, Box<Expr>)>

Optional operator and right-hand side (e.g., == false in .done == false)

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl PartialEq for ExprKind

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