Enum Expr 

pub enum Expr {
    Ref(String),
    Range(RangeRef),
    Number(f64),
    Str(String),
    Bool(bool),
    BinaryOp {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnOp,
        operand: Box<Expr>,
    },
    Call {
        name: String,
        args: Vec<Expr>,
    },
    Name(String),
    ErrorLit(ExcelError),
}

An owned Excel formula expression node.

Built by the workbook-compiler parser from CellRecord.formula; walked by the DAG reconstructor (refs/ranges/names → dependency edges) and the sheet_ir executor (leaf arithmetic → the pure-Rust scalar evaluator).

Variants

Ref(String)

A single-cell reference, $-anchors already stripped (e.g. "1_Inputs!E6" or a bare "E6"). Dependency identity does not depend on absolute vs relative (D-07), so the parser normalizes to a plain A1/sheet!A1 string.

Range(RangeRef)

A range reference (e.g. B2:B10), reusing the structured RangeRef (sheet stored ONCE). Expanded to per-member-cell edges by the DAG (D-06).

Number(f64)

A numeric literal.

Str(String)

A string literal (the ""-doubling already un-escaped by the lexer).

Bool(bool)

A boolean literal (TRUE/FALSE).

BinaryOp

A binary operation (left op right).

Fields

left: Box<Expr>

The left operand.

op: BinOp

The operator.

right: Box<Expr>

The right operand.

UnaryOp

A unary operation (op operand).

Fields

op: UnOp

The operator.

operand: Box<Expr>

The operand.

Call

A generic function call (D-02): name is checked against the dialect WHITELIST at parse time; the semantics layer dispatches on it.

Fields

name: String

The function name (e.g. "CEILING"), case as authored.

args: Vec<Expr>

The positional arguments.

Name(String)

A defined-name reference (resolved against the manifest defined-names in the DAG layer, D-07).

ErrorLit(ExcelError)

A literal Excel error parsed from the formula text (e.g. #REF!), wrapping the SHARED ExcelError (imported from crate::excel_error).

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<'de> Deserialize<'de> for Expr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Expr

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

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 Serialize for Expr

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 Expr