Enum Expr 

pub enum Expr {
    Literal(Literal),
    Null,
    Identifier(String),
    FieldAccess {
        receiver: Box<Expr>,
        field: String,
    },
    BinaryOp {
        op: BinaryOperator,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOperator,
        operand: Box<Expr>,
    },
    FunctionCall {
        name: String,
        args: Vec<Expr>,
    },
    Lambda {
        param: String,
        body: Box<Expr>,
    },
    Let {
        name: String,
        value: Box<Expr>,
        body: Box<Expr>,
    },
    If {
        condition: Box<Expr>,
        then_branch: Box<Expr>,
        else_branch: Box<Expr>,
    },
    Array(Vec<Expr>),
    Object(Vec<(String, Expr)>),
    Pipe {
        value: Box<Expr>,
        functions: Vec<Expr>,
    },
    Alternative {
        primary: Box<Expr>,
        alternative: Box<Expr>,
    },
    Guard {
        condition: Box<Expr>,
        body: Box<Expr>,
    },
    Date(String),
    DateTime(String),
    Duration(String),
    TemporalKeyword(TemporalKeyword),
    String(String),
}

Top-level ELO expression type

Represents any valid ELO expression that can be parsed and executed. This is an exhaustive enum of all expression forms in ELO.

Variants

Literal(Literal)

Literal values: numbers (int/float) or booleans

Null

Null literal

Identifier(String)

Variable reference (identifier)

FieldAccess

Field access: receiver.field (e.g., user.age)

Fields

receiver: Box<Expr>

The expression being accessed

field: String

The field name

BinaryOp

Binary operation: left op right

Fields

op: BinaryOperator

The binary operator

left: Box<Expr>

Left operand

right: Box<Expr>

Right operand

UnaryOp

Unary operation: op operand

Fields

op: UnaryOperator

The unary operator

operand: Box<Expr>

The operand

FunctionCall

Function call: name(args)

Fields

name: String

Function name

args: Vec<Expr>

Function arguments

Lambda

Lambda expression: param ~> body

Fields

param: String

Parameter name

body: Box<Expr>

Lambda body expression

Let

Let binding: let name = value in body

Fields

name: String

Variable name being bound

value: Box<Expr>

Value expression

body: Box<Expr>

Body expression (scope where binding is available)

If

If conditional: if condition then branch_a else branch_b

Fields

condition: Box<Expr>

Condition expression

then_branch: Box<Expr>

Then branch

else_branch: Box<Expr>

Else branch

Array(Vec<Expr>)

Array literal: [expr1, expr2, …]

Object(Vec<(String, Expr)>)

Object literal: {key1: value1, key2: value2, …}

Pipe

Pipe operator: expr |> func() |> …

Fields

value: Box<Expr>

The value being piped

functions: Vec<Expr>

Functions to pipe through (in order)

Alternative

Alternative operator: expr ?| default

Fields

primary: Box<Expr>

Primary expression

alternative: Box<Expr>

Alternative/default expression

Guard

Guard expression: guard condition in expr

Fields

condition: Box<Expr>

Condition that must be true

body: Box<Expr>

Expression to evaluate if guard passes

Date(String)

Date literal: @date(2024-01-15)

DateTime(String)

DateTime literal: @datetime(2024-01-15T10:30:00Z)

Duration(String)

Duration literal: @duration(P1D), @duration(PT1H30M)

TemporalKeyword(TemporalKeyword)

Temporal keyword: NOW, TODAY, TOMORROW, etc.

String(String)

String literal (explicitly quoted with single quotes)

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.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> 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 StructuralPartialEq for Expr