Enum Postfix

pub enum Postfix {
    Empty,
    Function(String, Box<Expression>),
    Index(Box<Postfix>, Box<Expression>),
    Method(Box<Postfix>, String, Box<Expression>),
    Inference(Reference, Box<Expression>),
    Primary(Box<Primary>),
}

Represents a postfix expression in the AIMX grammar.

Postfix expressions are operations that occur after their operands, following the left-to-right associativity rule. This enum captures all possible postfix operations including function calls, method calls, array indexing, and inference operations, as well as flattened primary expressions for optimization.

Variants

• Empty - The empty placeholder _ representing no operation
• Function - Function call with identifier and arguments
• Index - Array indexing operation with base and index
• Method - Method call on an object with method name and arguments
• Inference - Inference call on a reference with arguments
• Primary - Flattened primary expression (optimization)

Examples

use aimx::expressions::postfix::Postfix;
use aimx::expressions::primary::Primary;
use aimx::Literal;
 
// Empty placeholder
let empty = Postfix::Empty;
assert!(empty.is_empty());
 
// Function call
let args = aimx::Expression::Empty;
let function = Postfix::Function("sum".to_string(), Box::new(args));
 
// Array indexing
let base = Box::new(Postfix::Primary(Box::new(Primary::Literal(Literal::Number(42.0)))));
let index = Box::new(aimx::Expression::Empty);
let index_op = Postfix::Index(base, index);
 
// Method call
let obj = Box::new(Postfix::Primary(Box::new(Primary::Literal(Literal::Text("data".to_string())))));
let method = Postfix::Method(obj, "to_upper".to_string(), Box::new(aimx::Expression::Empty));

AST Flattening

The Primary variant represents an optimization where expressions that consist solely of primary expressions (literals, references, parentheses) are flattened to reduce AST depth and improve evaluation performance.

See Also

• parse_postfix - Function to parse postfix expressions from text
• ExpressionLike - Trait for expression evaluation
• Primary - Type of flattened primary expressions

Variants

Empty

The empty placeholder _

Function(String, Box<Expression>)

Function call with function name and argument expression

Index(Box<Postfix>, Box<Expression>)

Array indexing operation with base and index expressions

Method(Box<Postfix>, String, Box<Expression>)

Method call on an object with method name and arguments

Inference(Reference, Box<Expression>)

Inference call on a reference and arguments

Primary(Box<Primary>)

Primary flattened AST optimization

Implementations

impl Postfix

pub fn is_empty(&self) -> bool

Check if this postfix expression represents an empty placeholder.

Returns

• bool - True if this is an Empty postfix expression, false otherwise

Examples

use aimx::expressions::{
    postfix::Postfix,
    primary::Primary,
};
use aimx::Literal;
 
let empty = Postfix::Empty;
assert!(empty.is_empty());
 
let literal = Postfix::Primary(Box::new(Primary::Literal(Literal::Number(42.0))));
assert!(!literal.is_empty());

Trait Implementations

impl Clone for Postfix

fn clone(&self) -> Postfix

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Postfix

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

Formats the value using the given formatter.

impl Display for Postfix

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

Formats the value using the given formatter.

impl ExpressionLike for Postfix

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

Evaluate this postfix expression within the given context.

This method recursively evaluates the postfix expression tree, delegating to the appropriate evaluation methods for each postfix variant. It handles function calls, method calls, array indexing, and inference operations.

Arguments

• context - The evaluation context providing variable values, function implementations, and method implementations

Returns

Returns a Result containing the evaluated Value if successful, or an error if evaluation fails.

Evaluation Strategy

• Empty expressions return Value::Empty
• Function expressions delegate to ContextLike::function_call
• Index expressions perform array indexing with bounds checking
• Method expressions delegate to ContextLike::method_call
• Inference expressions delegate to ContextLike::inference_call
• Primary expressions delegate to Primary::evaluate

Examples

use aimx::expressions::postfix::Postfix;
use aimx::expressions::primary::Primary;
use aimx::{Context, Literal, ExpressionLike};
 
// Evaluate empty placeholder
let mut context = Context::new();
let postfix = Postfix::Empty;
let result = postfix.evaluate(&mut context).unwrap();
assert_eq!(result, aimx::Value::Empty);
 
// Evaluate literal expression
let primary = Primary::Literal(Literal::Number(42.0));
let postfix = Postfix::Primary(Box::new(primary));
let result = postfix.evaluate(&mut context).unwrap();
assert_eq!(result.to_string(), "42");

Error Handling

This method returns detailed error messages including:

• Array index out of bounds errors
• Type mismatch errors for array indexing
• Function and method call failures
• Inference call failures

See Also

• ContextLike - Trait for evaluation contexts
• Value - Result type returned by evaluation
• Primary::evaluate - Evaluation of primary expressions

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 Postfix

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