Enum Expr 

pub enum Expr {
    Int(i64),
    Float(f64),
    String(String),
    Bool(bool),
    None,
    Decimal(String),
    Ident(String),
    BinOp {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    Call {
        function: Box<Expr>,
        args: Vec<Expr>,
    },
    NamedArg {
        name: String,
        value: Box<Expr>,
    },
    Pipe {
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Member {
        object: Box<Expr>,
        field: String,
    },
    Index {
        object: Box<Expr>,
        index: Box<Expr>,
    },
    List(Vec<Expr>),
    Map(Vec<(Expr, Expr)>),
    Block {
        stmts: Vec<Stmt>,
        expr: Option<Box<Expr>>,
    },
    Case {
        arms: Vec<MatchArm>,
    },
    Match {
        subject: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    Closure {
        params: Vec<Param>,
        return_type: Option<TypeExpr>,
        body: ClosureBody,
    },
    Range {
        start: Box<Expr>,
        end: Box<Expr>,
    },
    NullCoalesce {
        expr: Box<Expr>,
        default: Box<Expr>,
    },
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
    },
    StructInit {
        name: String,
        fields: Vec<(String, Expr)>,
    },
    EnumVariant {
        enum_name: String,
        variant: String,
        args: Vec<Expr>,
    },
    Await(Box<Expr>),
    Yield(Option<Box<Expr>>),
    Try(Box<Expr>),
}

Expressions

Variants

Int(i64)

Float(f64)

String(String)

Bool(bool)

None

Decimal(String)

Decimal literal: 3.14d — fixed-point decimal

Ident(String)

Variable reference

BinOp

Binary operation: left op right

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

UnaryOp

Unary operation: op expr

Fields

op: UnaryOp

expr: Box<Expr>

Call

Function call: name(args)

Fields

function: Box<Expr>

args: Vec<Expr>

NamedArg

Named argument in a call: key: value

Fields

name: String

value: Box<Expr>

Pipe

Pipe: left |> right

Fields

left: Box<Expr>

right: Box<Expr>

Member

Member access: expr.field

Fields

object: Box<Expr>

field: String

Index

Index access: expr[index]

Fields

object: Box<Expr>

index: Box<Expr>

List(Vec<Expr>)

List literal: [a, b, c]

Map(Vec<(Expr, Expr)>)

Map literal: { key: value, … }

Block

Block expression: { stmts; expr }

Fields

stmts: Vec<Stmt>

expr: Option<Box<Expr>>

Case

case { pattern => expr, … }

Fields

arms: Vec<MatchArm>

Match

match expr { pattern => expr, … }

Fields

subject: Box<Expr>

arms: Vec<MatchArm>

Closure

Closure: (params) => expr or (params) -> Type { stmts; expr }

Fields

params: Vec<Param>

return_type: Option<TypeExpr>

body: ClosureBody

Range

Range: start..end

Fields

start: Box<Expr>

end: Box<Expr>

NullCoalesce

Null coalesce: expr ?? default

Fields

expr: Box<Expr>

default: Box<Expr>

Assign

Assignment: name = value (for reassigning mut variables)

Fields

target: Box<Expr>

value: Box<Expr>

StructInit

Struct initialization: Name { field: value, … }

Fields

name: String

fields: Vec<(String, Expr)>

EnumVariant

Enum variant: Enum::Variant or Enum::Variant(args)

Fields

enum_name: String

variant: String

args: Vec<Expr>

Await(Box<Expr>)

Await expression: await expr

Yield(Option<Box<Expr>>)

Yield expression: yield expr or bare yield

Try(Box<Expr>)

Try propagation: expr? — unwrap Result/Option or early return

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.