aimx/expressions/

closure.rs

//! Closure expression parsing and evaluation for the `=>` operator.
//! Provides parsing of closure syntax and runtime representation used by AIMX.

use crate::{
    aim::{ContextLike, WriterLike, Writer},
    expressions::{Conditional, ExpressionLike, Primary, parse_conditional, parse_arc_identifier},
    values::Value,
};
use anyhow::Result;
use nom::{
    IResult, Parser,
    bytes::tag,
    character::complete::{char, multispace0},
    sequence::{delimited, separated_pair},
};
use std::{
    fmt,
    sync::Arc,
};

/// Closure (anonymous function) expression.
///
/// Variants:
/// - `One(name, body)` – single-parameter closure.
/// - `Two(name1, name2, body)` – two-parameter closure.
/// - `Primary(primary)` – primary/conditional expression treated as a closure body.
#[derive(Debug, Clone, PartialEq)]
pub enum Closure {
    One(Arc<str>, Conditional),
    Two(Arc<str>, Arc<str>, Conditional),
    /// Primary flattened AST optimization.
    Primary(Box<Primary>),
}

impl Closure {
    /// Evaluate the closure body using parameter bindings already set in `context`.
    pub fn invoke(&self, context: &mut dyn ContextLike) -> Result<Arc<Value>> {
        match self {
            Closure::Two(one, two, conditional) => {
                context.set_key(0, one.clone());
                context.set_key(1, two.clone());
                conditional.evaluate(context)
            }
            Closure::One(one, conditional) => {
                context.set_key(0, one.clone());
                conditional.evaluate(context)
            }
            Closure::Primary(primary) => primary.evaluate(context),
        }
    }

    /// Call the closure with argument value(s) using the AIMX calling convention.
    ///
    /// - Propagates `Value::Errata` without evaluation.
    /// - Binds a single value to parameter index `0`.
    /// - For arrays, binds element `0` to parameter `0` and element `1` (if present) to parameter `1`.
    /// - Evaluates inside a closure scope (`start_closure` / `end_closure`).
    pub fn call(&self, context: &mut dyn ContextLike, arg: Arc<Value>) -> Result<Arc<Value>> {
        if arg.is_error() {
            return Ok(arg);
        }

        let stack = context.start_closure();

        match &*arg {
            Value::Literal(_) | Value::Errata(_) | Value::Empty => {
                context.set_parameter(0, arg);
            }
            Value::Array(array) => {
                if !array.is_empty() {
                    context.set_parameter(0, array[0].clone());
                    if array.len() > 1 {
                        context.set_parameter(1, array[1].clone());
                    }
                }
            }
            _ => {}
        }

        let result = self.invoke(context);
        context.end_closure(stack);
        result
    }

    /// Write the closure in AIMX syntax.
    pub fn print(&self, writer: &mut Writer) {
        match self {
            Closure::One(one, conditional) => {
                writer.write_str(one);
                writer.write_str(" => ");
                conditional.print(writer);
            }
            Closure::Two(one, two, conditional) => {
                writer.write_char('(');
                writer.write_str(one);
                writer.write_str(", ");
                writer.write_str(two);
                writer.write_str(") => ");
                conditional.print(writer);
            }
            Closure::Primary(primary) => primary.print(writer),
        }
    }
}

/// Parse a single-parameter closure: `identifier => expression`.
fn single_closure(input: &str) -> IResult<&str, Closure> {
    let (input, (one, _, conditional)) = (
        parse_arc_identifier,
        delimited(multispace0, tag("=>"), multispace0),
        parse_conditional,
    ).parse(input)?;
    Ok((input, Closure::One(one, conditional)))
}

/// Parse a two-parameter closure: `(identifier, identifier) => expression`.
fn double_closure(input: &str) -> IResult<&str, Closure> {
    let (input, ((one, two), _, conditional)) = (delimited(
        char('('),
        separated_pair(
            parse_arc_identifier,
            delimited(multispace0, char(','), multispace0),
            parse_arc_identifier,
        ),
        char(')'),
        ),
        delimited(multispace0, tag("=>"), multispace0),
        parse_conditional,
    ).parse(input)?;
    Ok((input, Closure::Two(one, two, conditional)))
}

/// Parse a closure expression or fallback conditional body.
///
/// If standard closure syntax does not match, falls back to [`parse_closure_conditional`].
pub fn parse_closure(input: &str) -> IResult<&str, Closure> {
    if input.starts_with('(') {
        if let Ok((input, closure)) = double_closure(input) {
            return Ok((input, closure));
        }
    } else if let Ok((input, closure)) = single_closure(input) {
        return Ok((input, closure));
    }
    parse_closure_conditional(input)
}

/// Parse a closure from a conditional expression as `Closure::Primary`.
pub fn parse_closure_conditional(input: &str) -> IResult<&str, Closure> {
    let (input, conditional) = parse_conditional(input)?;
    let closure = match conditional {
        Conditional::Primary(primary) => Closure::Primary(primary),
        _ => Closure::Primary(Box::new(Primary::Conditional(conditional))),
    };
    Ok((input, closure))
}

impl ExpressionLike for Closure {
    /// Evaluate to a runtime value.
    ///
    /// - `Primary` evaluates directly.
    /// - Other variants return `Value::Closure` for later invocation.
    fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Arc<Value>> {
        match self {
            Closure::Primary(primary) => primary.evaluate(context),
            // NOTE: CLONE HERE
            _ => Ok(Arc::new(Value::Closure(Arc::new(self.clone())))),
        }
    }

    /// Return the formula-string representation (round-trippable by the parser).
    fn to_formula(&self) -> String {
        let mut writer = Writer::formulizer();
        self.print(&mut writer);
        writer.finish()
    }
}

impl WriterLike for Closure {
    fn write(&self, writer: &mut Writer) {
        self.print(writer);
    }
}

impl fmt::Display for Closure {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_stringized())
    }
}