cljrs_runtime/interp/

destructure.rs

//! Sequential and associative destructuring for `let*`, `fn*`, and `loop*`.

use crate::builtins::form::form_to_value;
use cljrs_gc::GcPtr;
use cljrs_reader::Form;
use cljrs_reader::form::FormKind;
use cljrs_value::{Keyword, PersistentList, Symbol, Value, ValueError, ValueResult};
use std::sync::Arc;

use crate::env::env::Env;
use crate::env::error::{EvalError, EvalResult};

/// Bind a destructuring pattern `pattern` against `val` in `env`.
///
/// Supports:
/// - Plain symbol binding
/// - `[a b]` sequential destructuring (recursive)
pub fn bind_pattern(pattern: &Form, val: Value, env: &mut Env) -> EvalResult<()> {
    match &pattern.kind {
        FormKind::Symbol(s) => {
            // Plain binding, including `_`.
            env.bind(Arc::from(s.as_str()), val);
            Ok(())
        }
        FormKind::Vector(forms) => bind_sequential(forms, &val, env),
        FormKind::Map(forms) => bind_associative(forms, &val, env),
        // A `^long x` (etc.) binding carries a primitive type hint that the
        // tree-walk interpreter ignores; bind the underlying pattern.
        FormKind::Meta(_, inner) => bind_pattern(inner, val, env),
        _ => Err(EvalError::Runtime(format!(
            "unsupported binding pattern: {:?}",
            pattern.kind
        ))),
    }
}

/// Bind a sequential destructuring pattern against `val`.
///
/// Grammar of `pattern`:
/// ```text
/// [sym* (& rest)? (:as alias)?]
/// ```
pub fn bind_sequential(pattern: &[Form], val: &Value, env: &mut Env) -> EvalResult<()> {
    let items = value_to_seq_vec(val).map_err(crate::env::error::value_error_to_eval_error)?;
    let mut idx = 0usize;
    let mut i = 0usize;

    while i < pattern.len() {
        let p = &pattern[i];

        // `&` introduces a rest binding.
        if matches!(&p.kind, FormKind::Symbol(s) if s == "&") {
            i += 1;
            let rest_pat = pattern
                .get(i)
                .ok_or_else(|| EvalError::Runtime("& in destructuring requires a name".into()))?;
            let rest_list = if idx < items.len() {
                let rest_vals: Vec<Value> = items[idx..].to_vec();
                Value::List(GcPtr::new(PersistentList::from_iter(rest_vals)))
            } else {
                Value::Nil
            };
            bind_pattern(rest_pat, rest_list, env)?;
            i += 1;
            // Skip optional `:as` after rest.
            if i < pattern.len()
                && let FormKind::Keyword(k) = &pattern[i].kind
                && k == "as"
            {
                i += 1;
                let alias = pattern
                    .get(i)
                    .ok_or_else(|| EvalError::Runtime(":as requires a name".into()))?;
                bind_pattern(alias, val.clone(), env)?;
            }
            break;
        }

        // `:as` alias — must be last.
        if let FormKind::Keyword(k) = &p.kind
            && k == "as"
        {
            i += 1;
            let alias = pattern
                .get(i)
                .ok_or_else(|| EvalError::Runtime(":as requires a name".into()))?;
            bind_pattern(alias, val.clone(), env)?;
            break;
        }

        // Normal positional binding.
        let item = items.get(idx).cloned().unwrap_or(Value::Nil);
        bind_pattern(p, item, env)?;
        idx += 1;
        i += 1;
    }

    Ok(())
}

/// Convert a seqable Value to its elements, propagating lazy realization errors.
/// Non-seqable values retain the historical empty-vector result.
pub fn value_to_seq_vec(val: &Value) -> ValueResult<Vec<Value>> {
    // Realization can park or collect. The original chain retains both the
    // accumulated elements and each thunk's cached result throughout the walk.
    let _root = crate::env::gc_roots::root_value(val);
    let mut result = Vec::new();
    let mut current = val.clone();
    loop {
        match current.unwrap_meta() {
            Value::Nil => break,
            Value::LazySeq(ls) => {
                current = ls.get().try_realize().map_err(ValueError::Other)?;
            }
            Value::Cons(c) => {
                result.push(c.get().head.clone());
                current = c.get().tail.clone();
            }
            Value::List(l) => {
                result.extend(l.get().iter().cloned());
                break;
            }
            Value::Vector(v) => {
                result.extend(v.get().iter().cloned());
                break;
            }
            Value::Set(s) => {
                result.extend(s.iter().cloned());
                break;
            }
            Value::Map(m) => {
                m.for_each(|k, v| result.push(Value::map_entry(k.clone(), v.clone())));
                break;
            }
            _ => break,
        }
    }
    Ok(result)
}

// ── Associative destructuring ─────────────────────────────────────────────────

/// Bind a map destructuring pattern against `val` in `env`.
///
/// `pattern` is a flat `[key val key val ...]` slice from `FormKind::Map`.
///
/// Supports:
/// - `:keys [a b c]`   — bind symbols from keyword keys `:a`, `:b`, `:c`
/// - `:strs [a b]`     — bind symbols from string keys `"a"`, `"b"`
/// - `:syms [a b]`     — bind symbols from symbol keys `'a`, `'b`
/// - `:as name`        — bind the whole value to `name`
/// - `:or {a default}` — default value for missing keys
/// - Regular `{sym :key}` direct bindings
pub fn bind_associative(pattern: &[Form], val: &Value, env: &mut Env) -> EvalResult<()> {
    // First pass: collect :or defaults.
    // The default is an EXPRESSION, held unevaluated until its symbol is bound.
    // Storing `form_to_value` here is what made `:or {rules default-rules}` bind
    // the SYMBOL `default-rules`; and evaluating every default up front would
    // break `{:keys [a b] :or {b (inc a)}}`, which Clojure supports because it
    // emits one `(get m :k default)` per symbol, in binding order.
    let mut defaults: std::collections::HashMap<String, Form> = std::collections::HashMap::new();
    let mut i = 0;
    while i + 1 < pattern.len() {
        let k = &pattern[i];
        let v = &pattern[i + 1];
        if let FormKind::Keyword(kw) = &k.kind
            && kw == "or"
        {
            // v is a map literal {sym default ...}
            if let FormKind::Map(or_forms) = &v.kind {
                let mut j = 0;
                while j + 1 < or_forms.len() {
                    if let FormKind::Symbol(sym) = &or_forms[j].kind {
                        defaults.insert(sym.clone(), or_forms[j + 1].clone());
                    }
                    j += 2;
                }
            }
        }
        i += 2;
    }

    let get_val = |key: &Value| -> Value {
        match val.unwrap_meta() {
            Value::Map(m) => m.get(key).unwrap_or(Value::Nil),
            _ => Value::Nil,
        }
    };

    let mut i = 0;
    while i + 1 < pattern.len() {
        let k = &pattern[i];
        let v = &pattern[i + 1];
        i += 2;

        // A `:keys`/`:strs`/`:syms` keyword may itself be namespace-qualified
        // (`:person/keys [a b]`), supplying a default namespace for every
        // unqualified symbol in its vector; an individual symbol's own
        // namespace (`ui/dest`) takes precedence over that default.
        let directive_ns = if let FormKind::Keyword(kw) = &k.kind {
            Keyword::parse(kw).namespace
        } else {
            None
        };
        let directive_name = if let FormKind::Keyword(kw) = &k.kind {
            Keyword::parse(kw).name.to_string()
        } else {
            String::new()
        };

        match &k.kind {
            FormKind::Keyword(_) if directive_name == "keys" => {
                if let FormKind::Vector(syms) = &v.kind {
                    for sym_form in syms {
                        if let FormKind::Symbol(sym) = &sym_form.kind {
                            let parsed = Symbol::parse(sym);
                            let key =
                                match parsed.namespace.clone().or_else(|| directive_ns.clone()) {
                                    Some(ns) => {
                                        Value::keyword(Keyword::qualified(ns, parsed.name.clone()))
                                    }
                                    None => Value::keyword(Keyword::simple(parsed.name.clone())),
                                };
                            let mut bound_val = get_val(&key);
                            if let Some(d) = defaults.get(parsed.name.as_ref()) {
                                // Evaluated whether or not the key was present:
                                // Clojure's `(get m :k default)` evaluates its
                                // third argument eagerly, so a throwing or
                                // side-effecting default must still fire here.
                                let dv = crate::interp::eval::eval(&d.clone(), env)?;
                                if matches!(bound_val, Value::Nil) {
                                    bound_val = dv;
                                }
                            }
                            env.bind(parsed.name.clone(), bound_val);
                        }
                    }
                }
            }
            FormKind::Keyword(kw) if kw == "strs" => {
                if let FormKind::Vector(syms) = &v.kind {
                    for sym_form in syms {
                        if let FormKind::Symbol(sym) = &sym_form.kind {
                            let key = Value::string(sym.clone());
                            let mut bound_val = get_val(&key);
                            if let Some(d) = defaults.get(sym.as_str()) {
                                // Evaluated whether or not the key was present:
                                // Clojure's `(get m :k default)` evaluates its
                                // third argument eagerly, so a throwing or
                                // side-effecting default must still fire here.
                                let dv = crate::interp::eval::eval(&d.clone(), env)?;
                                if matches!(bound_val, Value::Nil) {
                                    bound_val = dv;
                                }
                            }
                            env.bind(Arc::from(sym.as_str()), bound_val);
                        }
                    }
                }
            }
            FormKind::Keyword(_) if directive_name == "syms" => {
                if let FormKind::Vector(syms) = &v.kind {
                    for sym_form in syms {
                        if let FormKind::Symbol(sym) = &sym_form.kind {
                            let parsed = Symbol::parse(sym);
                            let key =
                                match parsed.namespace.clone().or_else(|| directive_ns.clone()) {
                                    Some(ns) => {
                                        Value::symbol(Symbol::qualified(ns, parsed.name.clone()))
                                    }
                                    None => Value::symbol(Symbol::simple(parsed.name.clone())),
                                };
                            let mut bound_val = get_val(&key);
                            if let Some(d) = defaults.get(parsed.name.as_ref()) {
                                // Evaluated whether or not the key was present:
                                // Clojure's `(get m :k default)` evaluates its
                                // third argument eagerly, so a throwing or
                                // side-effecting default must still fire here.
                                let dv = crate::interp::eval::eval(&d.clone(), env)?;
                                if matches!(bound_val, Value::Nil) {
                                    bound_val = dv;
                                }
                            }
                            env.bind(parsed.name.clone(), bound_val);
                        }
                    }
                }
            }
            FormKind::Keyword(kw) if kw == "as" => {
                if let FormKind::Symbol(sym) = &v.kind {
                    env.bind(Arc::from(sym.as_str()), val.clone());
                }
            }
            FormKind::Keyword(kw) if kw == "or" => {
                // Already processed in the first pass.
            }
            _ => {
                // Regular {binding-form lookup-key} pair.
                // In Clojure map destructuring {a :x}, the key position is the
                // binding target and the value position is the lookup key.
                let lookup_key = form_to_value(v)?;
                let mut bound_val = get_val(&lookup_key);
                // Apply defaults for simple symbol bindings.
                if let FormKind::Symbol(sym) = &k.kind
                    && let Some(d) = defaults.get(sym.as_str())
                {
                    let dv = crate::interp::eval::eval(&d.clone(), env)?;
                    if matches!(bound_val, Value::Nil) {
                        bound_val = dv;
                    }
                }
                // Bind via pattern to support nested destructuring.
                bind_pattern(k, bound_val, env)?;
            }
        }
    }
    Ok(())
}