Enum AstExpr

pub enum AstExpr {
    Constant(Real),
    Variable(String),
    Function {
        name: String,
        args: Vec<AstExpr>,
    },
    Array {
        name: String,
        index: Box<AstExpr>,
    },
    Attribute {
        base: String,
        attr: String,
    },
}

Abstract Syntax Tree (AST) node representing an expression.

The AST is the core data structure used for representing parsed expressions. Each variant of this enum represents a different type of expression node, forming a tree structure that can be evaluated to produce a result.

Variants

Constant(Real)

A literal numerical value.

Examples: 3.14, 42, -1.5

Variable(String)

A named variable reference.

Examples: x, temperature, result

Function

A function call with a name and list of argument expressions.

Examples: sin(x), max(a, b), sqrt(x*x + y*y)

Fields

name: String

The name of the function being called

args: Vec<AstExpr>

The arguments passed to the function

Array

An array element access.

Examples: array[0], values[i+1]

Fields

name: String

The name of the array

index: Box<AstExpr>

The expression for the index

Attribute

An attribute access on an object.

Examples: point.x, settings.value

Fields

base: String

The base object name

attr: String

The attribute name

Implementations

impl AstExpr

pub fn pow(self, exp: Real) -> Real

Helper method that raises a constant expression to a power.

This is primarily used in testing to evaluate power operations on constants. For non-constant expressions, it returns 0.0 as a default value.

Parameters

• exp - The exponent to raise the constant to

Returns

The constant raised to the given power, or 0.0 for non-constant expressions

Trait Implementations

impl Clone for AstExpr

fn clone(&self) -> AstExpr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AstExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for AstExpr

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