Struct Expression 

pub struct Expression { /* private fields */ }

A symbolic expression in postfix notation

Implementations

impl Expression

pub fn new() -> Self

Create an empty expression

pub fn parse(s: &str) -> Option<Self>

Parse a well-formed postfix expression (e.g., “32s1+s*”).

This validates stack discipline while parsing, so malformed or incomplete postfix strings return None instead of constructing an expression that will later panic during formatting.

pub fn symbols(&self) -> &[Symbol]

Get the symbols in this expression

pub fn len(&self) -> usize

Get the expression length

pub fn is_empty(&self) -> bool

Check if expression is empty

pub fn complexity(&self) -> u32

Get the complexity score

pub fn contains_x(&self) -> bool

Check if this expression contains the variable x

pub fn count_symbol(&self, sym: Symbol) -> u32

Count occurrences of a symbol in this expression.

pub fn is_valid(&self) -> bool

Check if this is a valid complete expression (stack depth = 1)

This method is part of the public API for external consumers who may want to validate expressions before processing them.

pub fn push(&mut self, sym: Symbol)

Append a symbol to this expression

pub fn pop(&mut self) -> Option<Symbol>

Remove the last symbol

pub fn push_with_table(&mut self, sym: Symbol, table: &SymbolTable)

Append a symbol using a symbol table for weight lookup

This is the table-driven version that uses per-run configuration instead of global overrides.

pub fn pop_with_table(&mut self, table: &SymbolTable) -> Option<Symbol>

Remove the last symbol using a symbol table for weight lookup

This is the table-driven version that uses per-run configuration instead of global overrides.

pub fn to_postfix(&self) -> String

Get the postfix string representation

pub fn try_to_infix(&self) -> Result<String, EvalError>

Convert to infix notation for display

Uses proper operator precedence and associativity rules:

• Precedence levels (higher = tighter binding):
  • 100: Atoms (constants, x, function calls)
  • 9: Power (right-associative)
  • 7: Unary operators (negation, reciprocal)
  • 6: Multiplication, division
  • 5: Addition, subtraction
• Right-associative operators (power) bind right-to-left
• Left-associative operators bind left-to-right

Convert to infix notation, returning Err(EvalError::StackUnderflow) if the expression is malformed (e.g. a binary operator with no operands).

Prefer this over to_infix when the expression may come from untrusted or user-provided input.

pub fn to_infix(&self) -> String

pub fn to_infix_or_postfix(&self) -> String

Format as infix, falling back to postfix when the expression is malformed.

Prefer this over to_infix at FFI and other untrusted-output boundaries where a panic would be unacceptable.

pub fn to_infix_with_table(&self, table: &SymbolTable) -> String

Convert to infix notation using a symbol table for display names

This is the table-driven version that uses per-run configuration instead of global overrides for symbol display names.

pub fn to_infix_with_format(&self, format: OutputFormat) -> String

Convert to infix notation with specified format

pub fn operator_count(&self) -> usize

Count the number of operators (non-atoms) in the expression

pub fn tree_depth(&self) -> usize

Compute the maximum depth of the expression tree

pub fn to_infix_mathematica(&self) -> String

pub fn to_infix_sympy(&self) -> String

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Default for Expression

fn default() -> Self

Returns the “default value” for a type.

impl Display for Expression

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

Formats the value using the given formatter.

impl Eq for Expression

impl Hash for Expression

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Expression

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