Enum ExprKind 

pub enum ExprKind {
    IntLit(i64),
    FloatLit {
        value: f64,
        lexeme: String,
    },
    DurationLit {
        value: i64,
        unit: DurationUnit,
        millis: i64,
    },
    StrLit(String),
    InterpStr(Vec<InterpPart>),
    BoolLit(bool),
    Ident(Ident),
    Call {
        name: Ident,
        type_args: Vec<TypeRef>,
        args: Vec<Expr>,
    },
    Lambda(LambdaExpr),
    BinOp(BinOp, Box<Expr>, Box<Expr>),
    UnaryOp(UnaryOp, Box<Expr>),
    Paren(Box<Expr>),
    Block(Block),
    If {
        cond: Box<Expr>,
        then_block: Box<Block>,
        else_block: Box<Block>,
    },
    Ok(Box<Expr>),
    Err(Box<Expr>),
    Question(Box<Expr>),
    ConstructorCall {
        type_name: Ident,
        method: Ident,
        args: Vec<Expr>,
    },
    RecordConstruction {
        type_name: Ident,
        fields: Vec<FieldInit>,
    },
    FieldAccess {
        receiver: Box<Expr>,
        field: Ident,
    },
    MethodCall {
        receiver: Box<Expr>,
        method: Ident,
        type_args: Vec<TypeRef>,
        args: Vec<Expr>,
    },
    Match {
        discriminant: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Is {
        value: Box<Expr>,
        pattern: Pattern,
    },
    Some(Box<Expr>),
    None,
    UnitLit,
    RecordSpread {
        type_name: Option<Ident>,
        base: Box<Expr>,
        overrides: Vec<FieldInit>,
    },
    EffectPure(Box<Expr>),
    Assert(Box<Expr>),
    Mock {
        type_ref: TypeRef,
        args: Vec<Expr>,
    },
    ListLit(Vec<Expr>),
}

Variants

IntLit(i64)

FloatLit

A float literal (v0.21). The lexeme is kept alongside the parsed value so emission and formatting are byte-stable (1e10 must not normalise to 10000000000).

Fields

value: f64

lexeme: String

DurationLit

A duration literal <int>.<unit> (v0.86, ADR 0112): 5.minutes, 30.days. The parser recognises the IntLit . <unit> shape and records the magnitude, the unit, and the resolved milliseconds (the value the emitter lowers to). Typed Duration.

Fields

value: i64

The integer magnitude as written (5 in 5.minutes).

unit: DurationUnit

The unit name (minutes), one of the closed set.

millis: i64

The value in milliseconds — value * unit factor.

StrLit(String)

InterpStr(Vec<InterpPart>)

An interpolated string "… \(expr) …" (v0.43, ADR 0075). Chunks and holes alternate. A plain "…" with no holes stays ExprKind::StrLit, so existing code and the emitter/formatter fast-path are untouched.

BoolLit(bool)

Ident(Ident)

Call

Fields

name: Ident

type_args: Vec<TypeRef>

v0.20a: explicit type arguments (name[T](…)); empty when absent.

args: Vec<Expr>

Lambda(LambdaExpr)

A lambda (v0.20a). See LambdaExpr.

BinOp(BinOp, Box<Expr>, Box<Expr>)

UnaryOp(UnaryOp, Box<Expr>)

Paren(Box<Expr>)

Block(Block)

{ stmts; expr } — block expression (v0.1).

If

if cond { then } else { else } (v0.1).

Fields

cond: Box<Expr>

then_block: Box<Block>

else_block: Box<Block>

Ok(Box<Expr>)

Ok(value) — Result success constructor (v0.1).

Err(Box<Expr>)

Err(error) — Result failure constructor (v0.1).

Question(Box<Expr>)

expr? — propagation operator (v0.1).

ConstructorCall

TypeName.method(args) — qualified static call on a type (v0.1: only refined-type of; v0.2: any static method or variant constructor for sum types). The resolver decides which.

Fields

type_name: Ident

method: Ident

args: Vec<Expr>

RecordConstruction

TypeName { field: value, ... } — record construction (v0.2).

Fields

type_name: Ident

fields: Vec<FieldInit>

FieldAccess

receiver.field — field access on a record value (v0.2). v0.3 adds .raw on opaque types within the defining commons.

Fields

receiver: Box<Expr>

field: Ident

MethodCall

receiver.method(args) — instance method call (v0.2). The resolver determines the receiver’s type and looks up the method.

Fields

receiver: Box<Expr>

method: Ident

type_args: Vec<TypeRef>

v0.22b: explicit type arguments on a qualified static (Json.decode[T](…)); empty when absent. The same-line-[ rule applies as for Call type application (0039).

args: Vec<Expr>

Match

match disc { arm+ } — pattern matching (v0.2).

Fields

discriminant: Box<Expr>

arms: Vec<MatchArm>

Is

expr is pattern — pattern test, returns Bool (v0.2).

Fields

value: Box<Expr>

pattern: Pattern

Some(Box<Expr>)

Some(value) — Option Some constructor (v0.2).

None

None — Option None constructor (v0.2).

UnitLit

() — unit literal (v0.5).

RecordSpread

TypeName { ...base, field: value, ... } or { ...base, ... } — record spread expression (v0.5).

Fields

type_name: Option<Ident>

Optional type prefix (TypeName { ...base }). Absent for the bare form used inside commit.

base: Box<Expr>

The base record being spread.

overrides: Vec<FieldInit>

Field overrides (always full name: value form — never shorthand).

EffectPure(Box<Expr>)

Effect.pure(value) — wrap a synchronous value into Effect[T] (v0.5). Recognised in the parser as a special-form.

Assert(Box<Expr>)

assert expr — assertion as an expression of type () (v0.9.1). Valid only inside test bodies. Evaluates expr (must be Bool); if false, the surrounding test case fails.

Mock

Mock[T], Mock[T](args) — test-context value construction (v0.9.4). args is empty for the bare form and holds the pin arguments for Mock[T](...). The record-override form Mock[T] { ... } is not yet parsed. Valid only inside test bodies; has type T.

Fields

type_ref: TypeRef

args: Vec<Expr>

ListLit(Vec<Expr>)

[a, b, c] — list literal (v0.20b). An empty [] requires an expected type (bynk.types.uninferable_element_type).

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.