Enum ExpressionKind 

pub enum ExpressionKind {
    Literal(Literal),
    Variable(String),
    BinaryOperation(BinaryOperator, Box<Expression>, Box<Expression>),
    UnaryOperation(UnaryOperator, Box<Expression>),
    Call(Box<Expression>, Vec<Expression>),
    Field(Box<Expression>, String),
    Index(Box<Expression>, Box<Expression>),
    Dereference(Box<Expression>),
    Convert(Box<Expression>, Type),
    Transmute(Box<Expression>, Type),
    SizeOf(Type),
    TypeConstruction(String, Vec<(String, Expression)>),
    ArrayLiteral(Vec<Expression>),
    TupleLiteral(Vec<Expression>),
    Block(Block),
    If {
        condition: Box<Expression>,
        then_branch: Block,
        else_branch: Option<Block>,
    },
    Match {
        value: Box<Expression>,
        arms: Vec<MatchArm>,
    },
    Replace(Box<Expression>, Box<Expression>),
    OpAssign(ArithmeticOperator, Box<Expression>, Box<Expression>),
    Slice(Box<Expression>, Option<Box<Expression>>, Option<Box<Expression>>),
    Print(Vec<Expression>),
}

Expression variants.

Variants

Literal(Literal)

Literal value.

Variable(String)

Variable reference.

BinaryOperation(BinaryOperator, Box<Expression>, Box<Expression>)

Binary operation (e.g. a + b).

UnaryOperation(UnaryOperator, Box<Expression>)

Unary operation (e.g. -x).

Call(Box<Expression>, Vec<Expression>)

Function call with arguments.

Field(Box<Expression>, String)

Field access (e.g. x.field).

Index(Box<Expression>, Box<Expression>)

Index access (e.g. a[i]).

Dereference(Box<Expression>)

Pointer dereference.

Convert(Box<Expression>, Type)

Newtype conversion (Type: value, value.Type). Safe, type-checked.

Transmute(Box<Expression>, Type)

Unsafe pointer transmute (value as Type). Pointer ↔ integer/pointer only.

SizeOf(Type)

Size of a type.

TypeConstruction(String, Vec<(String, Expression)>)

Newtype construction with named fields (e.g. point: (x: 1.0, y: 2.0)).

ArrayLiteral(Vec<Expression>)

Array literal.

TupleLiteral(Vec<Expression>)

Tuple literal.

Block(Block)

Block expression.

If

Conditional expression.

Fields

condition: Box<Expression>

Condition.

then_branch: Block

Then branch.

else_branch: Option<Block>

Optional else branch.

Match

Match expression.

Fields

value: Box<Expression>

Value being matched.

arms: Vec<MatchArm>

Match arms.

Replace(Box<Expression>, Box<Expression>)

Replace: assigns new value, returns old value (like std::mem::replace).

OpAssign(ArithmeticOperator, Box<Expression>, Box<Expression>)

Compound assignment (+=, -=, *=, /=).

Slice(Box<Expression>, Option<Box<Expression>>, Option<Box<Expression>>)

Slice operation: converts array to slice. Full slice (no bounds) or sub-slice (start, end).

Print(Vec<Expression>)

Debug print (temporary intrinsic).

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.