Enum Expr 

pub enum Expr {
    Number(f64),
    Text(Arc<str>),
    Bool(bool),
    Error(CellError),
    Array(Vec<Vec<Expr>>),
    Ref(Reference),
    Name(String),
    Struct(StructRef),
    Unary(UnOp, Box<Expr>),
    Binary(BinOp, Box<Expr>, Box<Expr>),
    Call(String, Vec<Expr>),
    Invoke(Box<Expr>, Vec<Expr>),
    Missing,
    Paren(Box<Expr>),
}

A formula’s syntax tree.

A flat operator chain such as =A1+A2+… nests one Expr::Binary per operator on its left, so a formula as long as Excel allows (8,192 characters) is about 4,000 levels deep. Clone, PartialEq, Expr::walk and Expr::map therefore follow that left spine in a loop and recurse only into right-hand operands and real nesting, which the parser bounds.

Variants

Number(f64)

Text(Arc<str>)

Bool(bool)

Error(CellError)

Array(Vec<Vec<Expr>>)

Array constant {1,2;3,4} (rows of literal expressions).

Ref(Reference)

Name(String)

Defined name, table name or LET/LAMBDA parameter.

Struct(StructRef)

Unary(UnOp, Box<Expr>)

Binary(BinOp, Box<Expr>, Box<Expr>)

Call(String, Vec<Expr>)

Function call; the name is upper-case without _xlfn..

Invoke(Box<Expr>, Vec<Expr>)

Calling the result of an expression, e.g. LAMBDA(x,x+1)(2).

Missing

An omitted argument F(1,,3).

Paren(Box<Expr>)

Implementations

impl Expr

pub fn walk<'a>(&'a self, f: &mut dyn FnMut(&'a Expr))

Visits every node depth-first, parents before children, left to right.

pub fn map(self, f: &mut dyn FnMut(Expr) -> Expr) -> Expr

Rewrites every node bottom-up, children left to right before their parent.

pub fn references(&self) -> Vec<&Reference>

All references in the formula.

pub fn functions(&self) -> Vec<&str>

Function names used (upper-case).

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Self

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

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

Equality operator ==.

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

Inequality operator !=.

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.