pub enum Expr {
Show 55 variants
Literal(Literal, Span),
Identifier(String, Span),
DataRef(DataRef, Span),
DataDateTimeRef(DataDateTimeRef, Span),
DataRelativeAccess {
reference: Box<Expr>,
index: DataIndex,
span: Span,
},
PropertyAccess {
object: Box<Expr>,
property: String,
optional: bool,
span: Span,
},
IndexAccess {
object: Box<Expr>,
index: Box<Expr>,
end_index: Option<Box<Expr>>,
span: Span,
},
BinaryOp {
left: Box<Expr>,
op: BinaryOp,
right: Box<Expr>,
span: Span,
},
FuzzyComparison {
left: Box<Expr>,
op: FuzzyOp,
right: Box<Expr>,
tolerance: FuzzyTolerance,
span: Span,
},
UnaryOp {
op: UnaryOp,
operand: Box<Expr>,
span: Span,
},
FunctionCall {
name: String,
args: Vec<Expr>,
named_args: Vec<(String, Expr)>,
span: Span,
},
QualifiedFunctionCall {
namespace: String,
function: String,
args: Vec<Expr>,
named_args: Vec<(String, Expr)>,
span: Span,
},
EnumConstructor {
enum_name: TypePath,
variant: String,
payload: EnumConstructorPayload,
span: Span,
},
TimeRef(TimeReference, Span),
DateTime(DateTimeExpr, Span),
PatternRef(String, Span),
Conditional {
condition: Box<Expr>,
then_expr: Box<Expr>,
else_expr: Option<Box<Expr>>,
span: Span,
},
Object(Vec<ObjectEntry>, Span),
Array(Vec<Expr>, Span),
ListComprehension(Box<ListComprehension>, Span),
Block(BlockExpr, Span),
TypeAssertion {
expr: Box<Expr>,
type_annotation: TypeAnnotation,
meta_param_overrides: Option<HashMap<String, Expr>>,
span: Span,
},
InstanceOf {
expr: Box<Expr>,
type_annotation: TypeAnnotation,
span: Span,
},
FunctionExpr {
params: Vec<FunctionParameter>,
return_type: Option<TypeAnnotation>,
body: Vec<Statement>,
span: Span,
},
Duration(Duration, Span),
Spread(Box<Expr>, Span),
If(Box<IfExpr>, Span),
While(Box<WhileExpr>, Span),
For(Box<ForExpr>, Span),
Loop(Box<LoopExpr>, Span),
Let(Box<LetExpr>, Span),
Assign(Box<AssignExpr>, Span),
Break(Option<Box<Expr>>, Span),
Continue(Span),
Return(Option<Box<Expr>>, Span),
MethodCall {
receiver: Box<Expr>,
method: String,
args: Vec<Expr>,
named_args: Vec<(String, Expr)>,
optional: bool,
span: Span,
},
Match(Box<MatchExpr>, Span),
Unit(Span),
Range {
start: Option<Box<Expr>>,
end: Option<Box<Expr>>,
kind: RangeKind,
span: Span,
},
TimeframeContext {
timeframe: Timeframe,
expr: Box<Expr>,
span: Span,
},
TryOperator(Box<Expr>, Span),
UsingImpl {
expr: Box<Expr>,
impl_name: String,
span: Span,
},
SimulationCall {
name: String,
params: Vec<(String, Expr)>,
span: Span,
},
WindowExpr(Box<WindowExpr>, Span),
FromQuery(Box<FromQueryExpr>, Span),
StructLiteral {
type_name: TypePath,
fields: Vec<(String, Expr)>,
span: Span,
},
Await(Box<Expr>, Span),
Join(Box<JoinExpr>, Span),
Annotated {
annotation: Annotation,
target: Box<Expr>,
span: Span,
},
AsyncLet(Box<AsyncLetExpr>, Span),
AsyncScope(Box<Expr>, Span),
Comptime(Vec<Statement>, Span),
ComptimeFor(Box<ComptimeForExpr>, Span),
Reference {
expr: Box<Expr>,
is_mutable: bool,
span: Span,
},
TableRows(Vec<Vec<Expr>>, Span),
}Variants§
Literal(Literal, Span)
Literal values
Identifier(String, Span)
Variable/identifier reference
DataRef(DataRef, Span)
Data reference: data[0], data[-1], data[1:5]
DataDateTimeRef(DataDateTimeRef, Span)
DateTime-based data reference: data[@“2024-01-15”]
DataRelativeAccess
Relative access from a reference: ref[0], ref[-1]
PropertyAccess
Property access: expr.property or expr?.property
IndexAccess
Index access: expr[index] or expr[start:end]
BinaryOp
Binary operations
FuzzyComparison
Fuzzy comparison with explicit tolerance: a ~= b within 0.02
UnaryOp
Unary operations
FunctionCall
Function calls: sma(20), rsi(14), momentum(period: 10, threshold: 0.01)
QualifiedFunctionCall
Qualified namespace call: module::function(args)
Fields
EnumConstructor
Enum constructor: Enum::Variant, Enum::Variant(…), Enum::Variant { … }
TimeRef(TimeReference, Span)
Time reference: @today, @“2024-01-15”
DateTime(DateTimeExpr, Span)
DateTime expression: @“2024-01-15”, @market_open, etc.
PatternRef(String, Span)
Pattern reference in expressions
Conditional
Conditional expression: if cond then expr else expr
Object(Vec<ObjectEntry>, Span)
Object literal: { field1: expr1, field2: expr2, …spread }
Array(Vec<Expr>, Span)
Array literal: [1, 2, 3]
ListComprehension(Box<ListComprehension>, Span)
List comprehension: [expr for var in iter if cond]
Block(BlockExpr, Span)
Block expression: { let x = 10; x + 5 }
TypeAssertion
Type assertion: expr as Type or expr as Type { param: value }
Fields
type_annotation: TypeAnnotationInstanceOf
Instance check: expr instanceof Type
FunctionExpr
Function expression: function(x, y) { return x + y }
Duration(Duration, Span)
Duration literal: 30d, 1h, 15m
Spread(Box<Expr>, Span)
Spread expression: …expr (used in arrays and objects)
If(Box<IfExpr>, Span)
If expression: if condition { expr } else { expr }
While(Box<WhileExpr>, Span)
While expression: while condition { expr }
For(Box<ForExpr>, Span)
For expression: for x in iter { expr }
Loop(Box<LoopExpr>, Span)
Loop expression: loop { expr }
Let(Box<LetExpr>, Span)
Let binding expression: let x = value; expr
Assign(Box<AssignExpr>, Span)
Assignment expression: x = value (returns value)
Break(Option<Box<Expr>>, Span)
Break with optional value
Continue(Span)
Continue
Return(Option<Box<Expr>>, Span)
Return with optional value
MethodCall
Method call: expr.method(args) or expr?.method(args)
Fields
Match(Box<MatchExpr>, Span)
Match expression
Unit(Span)
Unit value (void)
Range
Range expression with Rust-style syntax
TimeframeContext
Timeframe context expression: on(1h) { expr }
TryOperator(Box<Expr>, Span)
Try operator for fallible propagation (Result/Option): expr?
UsingImpl
Named implementation selector: expr using ImplName
SimulationCall
Simulation call with inline parameters
WindowExpr(Box<WindowExpr>, Span)
Window function expression: expr OVER (partition by … order by …)
FromQuery(Box<FromQueryExpr>, Span)
LINQ-style from query expression Syntax: from var in source [clauses…] select expr
StructLiteral
Struct literal: TypeName { field: value, … }
Await(Box<Expr>, Span)
Await expression: await expr
Join(Box<JoinExpr>, Span)
Join expression: await join all|race|any|settle { branch, … }
Annotated
Annotated expression: @annotation expr
Used for expression-level annotations like @timeout(5s) fetch() or @timed computation()
Multiple annotations nest left-to-right: @retry(3) @timeout(5s) fetch() becomes
Annotated { @retry(3), target: Annotated { @timeout(5s), target: fetch() } }
AsyncLet(Box<AsyncLetExpr>, Span)
Async let expression: async let name = expr
Spawns a task and binds a future handle to a local variable.
AsyncScope(Box<Expr>, Span)
Async scope expression: async scope { ... }
Cancellation boundary — on scope exit, all pending tasks are cancelled in reverse order.
Comptime(Vec<Statement>, Span)
Compile-time block expression: comptime { stmts }
Evaluated at compile time via the mini-VM. The result replaces this node with a literal.
ComptimeFor(Box<ComptimeForExpr>, Span)
Compile-time for loop: comptime for field in target.fields { ... }
Unrolled at compile time. Each iteration is compiled with the loop variable
bound to the concrete field descriptor. Used inside comptime annotation handlers.
Reference
Reference expression: &expr or &mut expr.
Creates a shared or exclusive reference to a local variable.
Fields
TableRows(Vec<Vec<Expr>>, Span)
Table row literal: [a, b, c], [d, e, f]
Used with let t: Table<T> = [row1], [row2], ... syntax.
Each inner Vec