Enum Additive

pub enum Additive {
    Add(Box<Additive>, Multiplicative),
    Subtract(Box<Additive>, Multiplicative),
    Primary(Box<Primary>),
}

An additive expression node in the abstract syntax tree.

Represents an expression involving additive operations (+, -) or a lower-precedence expression that has been flattened in the AST.

Variants

• Add(Box<Additive>, Multiplicative) - Addition operation
• Subtract(Box<Additive>, Multiplicative) - Subtraction operation
• Primary(Primary) - Flattened variants from lower precedence levels

Examples

use aimx::expressions::additive::Additive;
use aimx::Literal;
use aimx::expressions::primary::Primary;
use aimx::expressions::multiplicative::Multiplicative;

// Represents the expression: 5 + 3
let add_expr = Additive::Add(
    Box::new(Additive::Primary(Box::new(Primary::Literal(Literal::Number(5.0))))),
    Multiplicative::Primary(Box::new(Primary::Literal(Literal::Number(3.0))))
);

Variants

Add(Box<Additive>, Multiplicative)

Subtract(Box<Additive>, Multiplicative)

Primary(Box<Primary>)

Primary flattened AST optimization

Trait Implementations

impl Clone for Additive

fn clone(&self) -> Additive

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Additive

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

Formats the value using the given formatter.

impl Display for Additive

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

Formats the value using the given formatter.

impl ExpressionLike for Additive

fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Value>

Evaluate the expression within the given context.

fn write(&self, writer: &mut Writer)

Write this expression to the provided writer.

fn to_sanitized(&self) -> String

Convert this expression to a sanitized string representation.

fn to_formula(&self) -> String

Convert this expression to a formula string representation.

impl PartialEq for Additive

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