Enum Expr 

pub enum Expr {
    IntLiteral(i64),
    FloatLiteral(f64),
    StringLiteral(String),
    CharLiteral(char),
    BoolLiteral(bool),
    Ident(String),
    BinaryOp {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOp,
        expr: Box<Expr>,
    },
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
    },
    CompoundAssign {
        target: Box<Expr>,
        op: BinOp,
        value: Box<Expr>,
    },
    Let {
        name: String,
        mutable: bool,
        type_ann: Option<Type>,
        value: Option<Box<Expr>>,
    },
    Block(Vec<Expr>),
    If {
        condition: Box<Expr>,
        then_block: Box<Expr>,
        else_block: Option<Box<Expr>>,
    },
    While {
        condition: Box<Expr>,
        body: Box<Expr>,
    },
    Loop {
        body: Box<Expr>,
    },
    For {
        var: String,
        iterator: Box<Expr>,
        body: Box<Expr>,
    },
    Range {
        start: Option<Box<Expr>>,
        end: Option<Box<Expr>>,
        inclusive: bool,
    },
    Break(Option<Box<Expr>>),
    Continue,
    Return(Option<Box<Expr>>),
    FnDef {
        name: String,
        params: Vec<(String, Type)>,
        return_type: Option<Type>,
        body: Box<Expr>,
    },
    FnCall {
        name: String,
        args: Vec<Expr>,
    },
    MethodCall {
        object: Box<Expr>,
        method: String,
        args: Vec<Expr>,
    },
    MacroCall {
        name: String,
        args: Vec<Expr>,
    },
    ArrayLiteral(Vec<Expr>),
    ArrayRepeat {
        value: Box<Expr>,
        count: Box<Expr>,
    },
    TupleLiteral(Vec<Expr>),
    Index {
        object: Box<Expr>,
        index: Box<Expr>,
    },
    FieldAccess {
        object: Box<Expr>,
        field: String,
    },
    StructDef {
        name: String,
        fields: Vec<(String, Type)>,
    },
    StructInit {
        name: String,
        fields: Vec<(String, Expr)>,
    },
    Match {
        expr: Box<Expr>,
        arms: Vec<MatchArm>,
    },
    TypeCast {
        expr: Box<Expr>,
        target_type: Type,
    },
    Closure {
        params: Vec<(String, Option<Type>)>,
        body: Box<Expr>,
    },
    Ref {
        expr: Box<Expr>,
        mutable: bool,
    },
    Deref(Box<Expr>),
    VecMacro(Vec<Expr>),
    Unit,
}

An expression or statement in the AST.

In VirtualRust, everything is an expression — even let bindings, if/while/for control flow, and function definitions.

Variants

IntLiteral(i64)

FloatLiteral(f64)

StringLiteral(String)

CharLiteral(char)

BoolLiteral(bool)

Ident(String)

BinaryOp

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

UnaryOp

Fields

op: UnaryOp

expr: Box<Expr>

Assign

Simple assignment (x = expr).

Fields

target: Box<Expr>

value: Box<Expr>

CompoundAssign

Compound assignment (x += expr, x -= expr, etc.).

Fields

target: Box<Expr>

op: BinOp

value: Box<Expr>

Let

Variable declaration (let [mut] name [: type] = expr).

Fields

name: String

mutable: bool

type_ann: Option<Type>

value: Option<Box<Expr>>

Block(Vec<Expr>)

A { ... } block of statements.

If

if condition { ... } [else { ... }]

Fields

condition: Box<Expr>

then_block: Box<Expr>

else_block: Option<Box<Expr>>

While

Fields

condition: Box<Expr>

body: Box<Expr>

Loop

Fields

body: Box<Expr>

For

Fields

var: String

iterator: Box<Expr>

body: Box<Expr>

Range

Fields

start: Option<Box<Expr>>

end: Option<Box<Expr>>

inclusive: bool

Break(Option<Box<Expr>>)

Continue

Return(Option<Box<Expr>>)

FnDef

Named function definition.

Fields

name: String

params: Vec<(String, Type)>

return_type: Option<Type>

body: Box<Expr>

FnCall

Fields

name: String

args: Vec<Expr>

MethodCall

Fields

object: Box<Expr>

method: String

args: Vec<Expr>

MacroCall

Fields

name: String

args: Vec<Expr>

ArrayLiteral(Vec<Expr>)

[a, b, c]

ArrayRepeat

[expr; count]

Fields

value: Box<Expr>

count: Box<Expr>

TupleLiteral(Vec<Expr>)

Index

Fields

object: Box<Expr>

index: Box<Expr>

FieldAccess

Fields

object: Box<Expr>

field: String

StructDef

struct Name { ... }

Fields

name: String

fields: Vec<(String, Type)>

StructInit

Fields

name: String

fields: Vec<(String, Expr)>

Match

match expr { arms... }

Fields

expr: Box<Expr>

arms: Vec<MatchArm>

TypeCast

expr as Type

Fields

expr: Box<Expr>

target_type: Type

Closure

|params| body

Fields

params: Vec<(String, Option<Type>)>

body: Box<Expr>

Ref

&expr or &mut expr

Fields

expr: Box<Expr>

mutable: bool

Deref(Box<Expr>)

*expr

VecMacro(Vec<Expr>)

vec![...]

Unit

The unit value ().

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.