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>),
    Specialize(Box<Expression>, Vec<GenericArgument>),
    Dereference(Box<Expression>),
    Convert(Box<Expression>, Type),
    SizeOf(Type),
    TypeConstruction(String, Vec<GenericArgument>, Vec<(String, Expression)>),
    Eval(Box<Expression>),
    ArrayLiteral(Vec<Expression>),
    ArrayRepeat(Box<Expression>, ConstExpression),
    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>),
    Print(Vec<Expression>),
}

The kind of an expression (untyped variant).

Variants

Literal(Literal)

Literal value (integer, float, string, bool).

Variable(String)

Variable reference by name.

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>)

expression(arguments) — callable tuple construction + evaluation.

Field(Box<Expression>, String)

Field access by name.

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

Index access (collection@index).

Specialize(Box<Expression>, Vec<GenericArgument>)

expression[T, N, ...] — generic specialization.

Dereference(Box<Expression>)

Pointer dereference.

Convert(Box<Expression>, Type)

Newtype conversion (Type: value or .Type downcast).

SizeOf(Type)

Size of a type in bytes.

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

Name { field: value, ... } — type construction (data only, no eval).

Eval(Box<Expression>)

expression! — explicit evaluation of a constructed value.

ArrayLiteral(Vec<Expression>)

Array literal ([a, b, c]).

ArrayRepeat(Box<Expression>, ConstExpression)

Array repeat ([value]count where count is a const expression).

TupleLiteral(Vec<Expression>)

Tuple literal ((a, b, c)).

Block(Block)

Block expression.

If

Conditional expression.

Fields

condition: Box<Expression>

Condition to evaluate.

then_branch: Block

Branch taken when true.

else_branch: Option<Block>

Optional branch taken when false.

Match

Pattern matching expression.

Fields

value: Box<Expression>

Value being matched.

arms: Vec<MatchArm>

Match arms evaluated in order.

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

Replace expression (:=, returns old value).

Print(Vec<Expression>)

Print expression for debugging.

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.