Enum Expression 

pub enum Expression {
    IntLiteral(i64),
    FloatLiteral(f64),
    StringLiteral(String),
    BoolLiteral(bool),
    NullLiteral,
    ArrayLiteral(Vec<Expression>),
    ObjectLiteral(Vec<(String, Expression)>),
    Range {
        start: Box<Expression>,
        end: Box<Expression>,
    },
    Variable(String),
    Binary {
        op: BinaryOp,
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Unary {
        op: UnaryOp,
        operand: Box<Expression>,
    },
    Ternary {
        condition: Box<Expression>,
        then_expr: Box<Expression>,
        else_expr: Box<Expression>,
    },
    ToolCall {
        name: String,
        args: Vec<Argument>,
    },
    Lambda {
        params: Vec<String>,
        body: Box<Expression>,
    },
    FieldAccess {
        object: Box<Expression>,
        field: String,
    },
    IndexAccess {
        array: Box<Expression>,
        index: Box<Expression>,
    },
    Grouping(Box<Expression>),
}

Expressions

Variants

IntLiteral(i64)

Integer literal expression

FloatLiteral(f64)

Floating-point literal expression

StringLiteral(String)

String literal expression

BoolLiteral(bool)

Boolean literal expression

NullLiteral

Null literal expression

ArrayLiteral(Vec<Expression>)

Array literal expression

ObjectLiteral(Vec<(String, Expression)>)

Object literal expression with key-value pairs

Range

Range expression [start..end]

Fields

start: Box<Expression>

Start expression of the range

end: Box<Expression>

End expression of the range (exclusive)

Variable(String)

Variable reference expression

Binary

Binary operation expression

Fields

op: BinaryOp

Binary operator to apply

left: Box<Expression>

Left operand expression

right: Box<Expression>

Right operand expression

Unary

Unary operation expression

Fields

op: UnaryOp

Unary operator to apply

operand: Box<Expression>

Operand expression

Ternary

Ternary conditional expression

Fields

condition: Box<Expression>

Condition expression to evaluate

then_expr: Box<Expression>

Expression to evaluate if condition is true

else_expr: Box<Expression>

Expression to evaluate if condition is false

ToolCall

Tool or function call

Fields

name: String

Name of the tool/function to call

args: Vec<Argument>

Arguments to pass to the tool

Lambda

Lambda function expression (x => x * 2)

Fields

params: Vec<String>

Parameter names for the lambda

body: Box<Expression>

Body expression of the lambda

FieldAccess

Field access expression (object.field)

Fields

object: Box<Expression>

Object being accessed

field: String

Name of the field to access

IndexAccess

Index access expression (array[index])

Fields

array: Box<Expression>

Array or collection being indexed

index: Box<Expression>

Index expression

Grouping(Box<Expression>)

Grouping expression with parentheses (expr)

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression