Enum Closure

pub enum Closure {
    One(String, Procedure),
    Two(String, String, Procedure),
    Primary(Box<Primary>),
}

Represents a closure (anonymous function) expression in the AIMX language.

Closures capture their environment and can be used as first-class values. They are typically created using the => operator and can have one or two parameters.

Variants

• One(String, Procedure): A closure with a single parameter
• Two(String, String, Procedure): A closure with two parameters
• Primary(Box<Primary>): An optimized representation when the closure is a simple primary expression

Examples

// Parses to Closure::One("x", procedure)
x => x + 1

// Parses to Closure::Two("x", "y", procedure)
(x, y) => x + y

Variants

One(String, Procedure)

Two(String, String, Procedure)

Primary(Box<Primary>)

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

Implementations

impl Closure

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

Invokes the closure with the current context.

This method evaluates the closure body after setting up the parameter bindings in the context. For closures with parameters, the parameters are bound to special context keys (0 for single parameter, 0 and 1 for double parameters).

Arguments

• context - The evaluation context

Returns

Returns Result<Value> containing the result of evaluating the closure body.

Examples

let mut context = Context::new();
let closure = Closure::One("x".to_string(), Procedure::Primary(Box::new(Primary::Literal(aimx::Literal::Number(42.0)))));
 
// Parameter values are set using the context's key mechanism
let param_name = "x".to_string();
context.set_key(0, &param_name);
let result = closure.invoke(&mut context)?;
// result should be Value::Literal(Literal::Number(42.0))

Trait Implementations

impl Clone for Closure

fn clone(&self) -> Closure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Closure

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

Formats the value using the given formatter.

impl Display for Closure

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

Formats the closure for display.

This implementation uses the Writable trait to format the closure 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 Closure

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

Evaluates the closure expression.

For primary closures (optimized simple expressions), this evaluates the expression directly. For parameterized closures, this returns a Value::Closure containing the closure itself, since closures with parameters need to be invoked with invoke() to evaluate them.

Arguments

• context - The evaluation context

Returns

Returns Result<Value> containing either the evaluated result (for primary closures) or the closure itself as a value (for parameterized closures).

Examples

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

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

Writes the closure expression to a writer.

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

Arguments

• writer - The writer to write the formatted closure to

fn to_sanitized(&self) -> String

Returns a sanitized string representation of the closure.

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 closure representation.

fn to_formula(&self) -> String

Returns a formula string representation of the closure.

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 Closure

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