Enum BeamExpr 

pub enum BeamExpr {
    LitInt(i64),
    LitFloat(f64),
    LitAtom(String),
    LitString(String),
    Nil,
    Var(String),
    Tuple(Vec<BeamExpr>),
    Cons(Box<BeamExpr>, Box<BeamExpr>),
    Map(Vec<(BeamExpr, BeamExpr)>),
    MapUpdate(Box<BeamExpr>, Vec<(BeamExpr, BeamExpr)>),
    Call {
        module: Option<String>,
        func: String,
        args: Vec<BeamExpr>,
    },
    CallExt {
        module: Box<BeamExpr>,
        func: Box<BeamExpr>,
        args: Vec<BeamExpr>,
    },
    Apply {
        fun: Box<BeamExpr>,
        args: Vec<BeamExpr>,
    },
    Case {
        subject: Box<BeamExpr>,
        clauses: Vec<BeamClause>,
    },
    Let {
        var: String,
        value: Box<BeamExpr>,
        body: Box<BeamExpr>,
    },
    Letrec {
        bindings: Vec<(String, Vec<String>, Box<BeamExpr>)>,
        body: Box<BeamExpr>,
    },
    Fun {
        params: Vec<String>,
        body: Box<BeamExpr>,
        arity: usize,
    },
    Primop {
        name: String,
        args: Vec<BeamExpr>,
    },
    Receive {
        clauses: Vec<BeamClause>,
        timeout: Option<Box<BeamExpr>>,
        timeout_action: Option<Box<BeamExpr>>,
    },
    Try {
        body: Box<BeamExpr>,
        vars: Vec<String>,
        handler: Box<BeamExpr>,
        evars: Vec<String>,
        catch_body: Box<BeamExpr>,
    },
    Seq(Box<BeamExpr>, Box<BeamExpr>),
    Binary(Vec<BeamBitSegment>),
}

Core Erlang-style expression representation.

These map closely to Core Erlang (the intermediate language used by the Erlang compiler before generating BEAM bytecode).

Variants

LitInt(i64)

Integer literal

LitFloat(f64)

Float literal

LitAtom(String)

Atom literal (e.g., ok, error, true, false)

LitString(String)

String (represented as binary or list of chars in BEAM)

Nil

Nil (empty list [])

Var(String)

Variable reference

Tuple(Vec<BeamExpr>)

Tuple constructor: {Elem1, Elem2, ...}

Cons(Box<BeamExpr>, Box<BeamExpr>)

List cons: [Head | Tail]

Map(Vec<(BeamExpr, BeamExpr)>)

Map literal: #{Key => Value, ...}

MapUpdate(Box<BeamExpr>, Vec<(BeamExpr, BeamExpr)>)

Map update: Map#{Key => Value}

Call

Local function call: Module:FuncName(Args...)

Fields

module: Option<String>

func: String

args: Vec<BeamExpr>

CallExt

Inter-module call: Module:Function(Args...)

Fields

module: Box<BeamExpr>

func: Box<BeamExpr>

args: Vec<BeamExpr>

Apply

Apply a fun value: Fun(Args...)

Fields

fun: Box<BeamExpr>

args: Vec<BeamExpr>

Case

Case expression for pattern matching

Fields

subject: Box<BeamExpr>

clauses: Vec<BeamClause>

Let

Let binding: let Var = Expr in Body

Fields

var: String

value: Box<BeamExpr>

body: Box<BeamExpr>

Letrec

Letrec (mutually recursive functions)

Fields

bindings: Vec<(String, Vec<String>, Box<BeamExpr>)>

body: Box<BeamExpr>

Fun

Fun literal (lambda / closure)

Fields

params: Vec<String>

body: Box<BeamExpr>

arity: usize

Primop

Primitive operation (BIF — Built-In Function)

Fields

name: String

args: Vec<BeamExpr>

Receive

Receive block with optional timeout

Fields

clauses: Vec<BeamClause>

timeout: Option<Box<BeamExpr>>

timeout_action: Option<Box<BeamExpr>>

Try

Try-catch block

Fields

body: Box<BeamExpr>

vars: Vec<String>

handler: Box<BeamExpr>

evars: Vec<String>

catch_body: Box<BeamExpr>

Seq(Box<BeamExpr>, Box<BeamExpr>)

Sequence (do-notation style)

Binary(Vec<BeamBitSegment>)

Binary construction: <<Segment, ...>>

Trait Implementations

impl Clone for BeamExpr

fn clone(&self) -> BeamExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BeamExpr

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

Formats the value using the given formatter.