Enum Expr 

pub enum Expr {
    Float(f64),
    Int(i32),
    Bool(bool),
    Null,
    String(SmolStr),
    Var(SmolStr, Span),
    Array(Box<[Self]>, Box<[Span]>),
    Map(Box<[(Self, Span, Self, Span)]>, Span),
    Struct(Box<[SmolStr]>, Box<[(SmolStr, Self, Span, Span)]>, Span),
    StructDeclare(SmolStr, Box<[(SmolStr, TypeExpr, Span)]>, Span),
    EnumDeclare(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, Span)]>, Span),
    NamespacedRef(Box<[SmolStr]>, Span),
    Match(Box<Self>, Box<[(Self, Box<[Self]>)]>, Option<Box<[Self]>>, Span),
    GetStructField(Box<Self>, SmolStr, Span, Span),
    SetStructField(Box<Self>, SmolStr, Box<Self>, Span, Span, Span),
    VarDeclare(SmolStr, Box<Self>),
    VarAssign(SmolStr, Box<Self>, Span),
    Condition(Box<Self>, Box<[Self]>, Span),
    InlineCondition(Box<Self>, Box<[Self]>, Span),
    ElseIfBlock(Box<Self>, Box<[Self]>),
    ElseBlock(Box<[Self]>),
    AnonymousFunction(Box<[SmolStr]>, Box<[Self]>, Span),
    WhileBlock(Box<Self>, Box<[Self]>),
    FunctionCall(Box<[Self]>, Box<[SmolStr]>, Span, Box<[Span]>),
    ObjFunctionCall(Box<Self>, Box<[Self]>, Box<[SmolStr]>, Span, Span, Box<[Span]>),
    FunctionDecl(SmolStr, Box<[(SmolStr, Option<TypeExpr>)]>, Rc<[Self]>, Span, Option<(TypeExpr, Span)>),
    ReturnVal(Box<Option<Self>>),
    ArrayGetIndex(Box<Self>, Box<Self>, Span),
    ArrayGetSlice(Box<Self>, Box<Self>, Box<Self>, Span),
    ArrayModify(Box<Self>, Box<Self>, Box<Self>, Span, Span),
    ForLoop(SmolStr, Box<Self>, Box<[Self]>, Span),
    IntForLoop(SmolStr, Box<Self>, Box<Self>, Box<[Self]>, Span, Span),
    ImportDylib(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span),
    HostBlock(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span),
    ImportFile(SmolStr, Option<SmolStr>, bool, Span),
    Break,
    Continue,
    EvalBlock(Box<[Self]>),
    LoopBlock(Box<[Self]>),
    TryCatchBlock(Box<[Self]>, SmolStr, Box<[Self]>),
    Mul(Box<Self>, Box<Self>, Span, Span),
    Div(Box<Self>, Box<Self>, Span, Span),
    Add(Box<Self>, Box<Self>, Span, Span),
    Sub(Box<Self>, Box<Self>, Span, Span),
    Mod(Box<Self>, Box<Self>, Span, Span),
    Pow(Box<Self>, Box<Self>, Span, Span),
    Eq(Box<Self>, Box<Self>),
    NotEq(Box<Self>, Box<Self>),
    Sup(Box<Self>, Box<Self>, Span, Span),
    SupEq(Box<Self>, Box<Self>, Span, Span),
    Inf(Box<Self>, Box<Self>, Span, Span),
    InfEq(Box<Self>, Box<Self>, Span, Span),
    BoolAnd(Box<Self>, Box<Self>, Span, Span),
    BoolOr(Box<Self>, Box<Self>, Span, Span),
    BoolNeg(Box<Self>, Span, Span),
    Neg(Box<Self>, Span, Span),
}

Variants

Float(f64)

Int(i32)

Bool(bool)

Null

String(SmolStr)

Var(SmolStr, Span)

Array(Box<[Self]>, Box<[Span]>)

Array(contents, [entire_array, elem_spans…])

Map(Box<[(Self, Span, Self, Span)]>, Span)

Map(key-value pairs, span)

Struct(Box<[SmolStr]>, Box<[(SmolStr, Self, Span, Span)]>, Span)

Struct(name, fields, span)

StructDeclare(SmolStr, Box<[(SmolStr, TypeExpr, Span)]>, Span)

StructDeclare(name, fields, span)

EnumDeclare(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, Span)]>, Span)

EnumDeclare(name, variants: [(variant_name, payload_types, name_span)], span)

NamespacedRef(Box<[SmolStr]>, Span)

NamespacedRef(path, span)

A bare namespaced identifier (Color::Red) with no call parentheses or struct braces. The only such form candela has is a nullary enum-variant construction; the compiler resolves it against the enum registry.

Match(Box<Self>, Box<[(Self, Box<[Self]>)]>, Option<Box<[Self]>>, Span)

Match(scrutinee, arms: [(pattern_expr, body)], wildcard_body, span)

The arm patterns are parsed as ordinary expressions; the compiler picks the lowering by the scrutinee’s static type. For an enum scrutinee each pattern is a variant pattern (Circle(r) binds the payload); otherwise each pattern is an equality test against the scrutinee.

GetStructField(Box<Self>, SmolStr, Span, Span)

GetStructField(struct_expr, field, struct_span, field_span, value_span)

SetStructField(Box<Self>, SmolStr, Box<Self>, Span, Span, Span)

SetStructField(struct_expr, field, new_expr, struct_span, field_span, value_span)

VarDeclare(SmolStr, Box<Self>)

VarDeclare(name, value),

VarAssign(SmolStr, Box<Self>, Span)

VarDeclare(name, value, start, end)

Condition(Box<Self>, Box<[Self]>, Span)

Condition(condition, code (contains else_if_blocks and potentially else_block), start, end)

InlineCondition(Box<Self>, Box<[Self]>, Span)

InlineCondition - expression-form if/else, always produces a value, must have an else branch

ElseIfBlock(Box<Self>, Box<[Self]>)

ElseBlock(Box<[Self]>)

AnonymousFunction(Box<[SmolStr]>, Box<[Self]>, Span)

AnonymousFunction(args, code, span)

WhileBlock(Box<Self>, Box<[Self]>)

FunctionCall(Box<[Self]>, Box<[SmolStr]>, Span, Box<[Span]>)

FunctionCall(args, (optional namespace + name), start, end, (arg_start,arg_end))

ObjFunctionCall(Box<Self>, Box<[Self]>, Box<[SmolStr]>, Span, Span, Box<[Span]>)

ObjFunctionCall(obj, args, namespace, obj_span, fn_span, arg_markers)

FunctionDecl(SmolStr, Box<[(SmolStr, Option<TypeExpr>)]>, Rc<[Self]>, Span, Option<(TypeExpr, Span)>)

FunctionDecl(name, args, code, name_span, return_type)

return_type carries the optional -> Type annotation together with the span of the annotation itself, which is what a mismatch between the declared and the returned type is reported against.

ReturnVal(Box<Option<Self>>)

ArrayGetIndex(Box<Self>, Box<Self>, Span)

ArrayGetSlice(Box<Self>, Box<Self>, Box<Self>, Span)

ArrayGetSlice(array, range_start, range_end, span)

ArrayModify(Box<Self>, Box<Self>, Box<Self>, Span, Span)

ForLoop(SmolStr, Box<Self>, Box<[Self]>, Span)

ForLoop(loop_var_name, loop_array+code, obj_markers)

IntForLoop(SmolStr, Box<Self>, Box<Self>, Box<[Self]>, Span, Span)

IntForLoop(loop_var_name, first_elem, final_elem, code)

ImportDylib(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span)

ImportDylib(lib_path, [(fn_name, fn_args, fn_return_type, fn_name_span)], (start, end))

HostBlock(SmolStr, Box<[(SmolStr, Box<[TypeExpr]>, TypeExpr, Span)]>, Span)

HostBlock(namespace, [(fn_name, fn_args, fn_return_type, fn_name_span)], (start, end))

Declares a host namespace whose functions are backed by Rust closures registered on the embedding crate::Engine. Mirrors Self::ImportDylib but dispatches to a registered closure instead of a C symbol.

ImportFile(SmolStr, Option<SmolStr>, bool, Span)

ImportFile(path, alias, is_logical, (start, end))

is_logical marks a library import (import "std/string";, an extensionless path): the resolver maps it straight to the shipped library directory and never looks source-relative. A .cdl file import (import "./local.cdl";) has is_logical false and resolves source-relative first. alias is Some for import ... as name;, which binds the module under name::; a bare import (None) merges the module’s symbols into the importing file’s scope.

Break

Continue

EvalBlock(Box<[Self]>)

LoopBlock(Box<[Self]>)

TryCatchBlock(Box<[Self]>, SmolStr, Box<[Self]>)

TryCatchBlock(try_code, err_var, catch_code)

Mul(Box<Self>, Box<Self>, Span, Span)

Div(Box<Self>, Box<Self>, Span, Span)

Add(Box<Self>, Box<Self>, Span, Span)

Sub(Box<Self>, Box<Self>, Span, Span)

Mod(Box<Self>, Box<Self>, Span, Span)

Pow(Box<Self>, Box<Self>, Span, Span)

Eq(Box<Self>, Box<Self>)

NotEq(Box<Self>, Box<Self>)

Sup(Box<Self>, Box<Self>, Span, Span)

SupEq(Box<Self>, Box<Self>, Span, Span)

Inf(Box<Self>, Box<Self>, Span, Span)

InfEq(Box<Self>, Box<Self>, Span, Span)

BoolAnd(Box<Self>, Box<Self>, Span, Span)

BoolOr(Box<Self>, Box<Self>, Span, Span)

BoolNeg(Box<Self>, Span, Span)

Neg(Box<Self>, Span, Span)

Implementations

impl Expr

pub fn infer_type( &self, v: &mut Vec<Variable>, ctx: Ctx, state: &mut State<'_>, ) -> DataType

Infers this expression’s static DataType without emitting code.

Panics

Panics when a call node carries an empty namespace path, which the parser never produces.

impl Expr

pub const fn is_constant_literal(&self) -> bool

pub fn compile( &self, v: &mut Vec<Variable>, ctx: Ctx, state: &mut State<'_>, output: &mut Vec<Instr>, tgt_id: Option<u16>, var_assignment: bool, uses_id: bool, ) -> Option<u16>

pub fn compile_with_code_context( &self, v: &mut Vec<Variable>, ctx: Ctx, state: &mut State<'_>, output: &mut Vec<Instr>, tgt_id: Option<u16>, var_assignment: bool, remaining_code: &[Self], uses_id: bool, ) -> Option<u16>

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