Enum Procedure

pub enum Procedure {
    Array(Vec<Box<Conditional>>),
    Primary(Box<Primary>),
}

Represents a procedure (sequence of expressions) in the AIMX language.

Procedures are sequences of conditional expressions that can be evaluated sequentially. They are typically used as the body of closure expressions.

Variants

• Array(Vec<Box<Conditional>>): A sequence of conditional expressions separated by semicolons
• Primary(Box<Primary>): An optimized representation when the procedure is a simple primary expression

Evaluation Behavior

When a procedure contains multiple expressions, they are evaluated in order and the result of the last expression is returned. This allows for sequencing operations while maintaining a functional programming style.

Examples

// Parses to Procedure::Primary(expression)
x + 1

// Parses to Procedure::Array([expression1, expression2, ...])
x * 2; x + 3; x - 1

Variants

Array(Vec<Box<Conditional>>)

Primary(Box<Primary>)

Primary flattened AST optimization - used when the procedure is a simple primary expression

Trait Implementations

impl Clone for Procedure

fn clone(&self) -> Procedure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Procedure

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

Formats the value using the given formatter.

impl Display for Procedure

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

Formats the procedure for display.

This implementation uses the Writable trait to format the procedure as a string suitable for user display.

Arguments

• f - The formatter to write to

Returns

Returns fmt::Result indicating success or failure.

impl ExpressionLike for Procedure

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

Evaluates the procedure expression.

For procedure arrays, this evaluates each conditional expression in sequence and returns the result of the last expression. For primary procedures, this evaluates the single expression directly.

Arguments

• context - The evaluation context

Returns

Returns Result<Value> containing the result of evaluating the procedure.

Examples

let mut context = Context::new();
let procedure = Procedure::Primary(Box::new(Primary::Literal(aimx::Literal::Number(42.0))));
let result = procedure.evaluate(&mut context)?;
// result should be Value::Literal(Literal::Number(42.0))

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

Writes the procedure expression to a writer.

This method formats the procedure according to its variant and writes it to the provided writer. The output matches the AIMX syntax for procedures.

Arguments

• writer - The writer to write the formatted procedure to

fn to_sanitized(&self) -> String

Returns a sanitized string representation of the procedure.

Sanitized output is suitable for display to users and may include formatting that makes the expression easier to read.

Returns

Returns a String containing the sanitized procedure representation.

fn to_formula(&self) -> String

Returns a formula string representation of the procedure.

Formula output is suitable for use as input to the parser and matches the exact AIMX syntax.

Returns

Returns a String containing the formula representation.

impl PartialEq for Procedure

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