mumu 0.11.1

Lava Mumu is a language for those in the now and that know
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::parser::types::{FunctionValue, Value, ComposeMode};
use crate::parser::interpreter::Interpreter;
use std::sync::{Arc, Mutex};

pub fn handle_composition(
    interp: &mut Interpreter,
    f_vec: Vec<Box<FunctionValue>>,
    mode: ComposeMode,
    args: Vec<Value>,
) -> Result<Value, String> {
    if args.len() != 1 {
        return Err(format!("Composition => expected 1 argument, got {}", args.len()));
    }
    let mut current_val = args.into_iter().next().unwrap();
    match mode {
        ComposeMode::Compose => {
            for fv_box in f_vec.iter().rev() {
                current_val = super::apply::apply_n_ary_function_value(interp, fv_box.clone(), vec![current_val])?;
            }
        }
        ComposeMode::Pipe => {
            for fv_box in f_vec.iter() {
                current_val = super::apply::apply_n_ary_function_value(interp, fv_box.clone(), vec![current_val])?;
            }
        }
    }
    Ok(current_val)
}

pub fn handle_composition_partial(
    _interp: &mut Interpreter,
    mode: ComposeMode,
    mut slots: Vec<Option<Box<FunctionValue>>>,
    args: Vec<Value>,
) -> Result<Value, String> {
    for val in args {
        let mut assigned = false;
        for slot in slots.iter_mut() {
            if slot.is_none() {
                match val {
                    Value::Function(fb) => {
                        *slot = Some(fb);
                        assigned = true;
                        break;
                    }
                    Value::Placeholder => {
                        assigned = true;
                        break;
                    }
                    other => {
                        return Err(format!(
                            "CompositionPartial => slot expects function, got {:?}",
                            other
                        ));
                    }
                }
            }
            if assigned {
                break;
            }
        }
        if !assigned {
            return Err("CompositionPartial => no open slot or unexpected argument".to_string());
        }
    }
    if slots.iter().all(|mb| mb.is_some()) {
        let final_fvec: Vec<Box<FunctionValue>> =
            slots.into_iter().map(|op| op.unwrap()).collect();
        Ok(Value::Function(Box::new(FunctionValue::Composition(final_fvec, mode))))
    } else {
        Ok(Value::Function(Box::new(FunctionValue::CompositionPartial { mode, slots })))
    }
}

pub fn handle_curried_prop(
    _interp: &mut Interpreter,
    k: String,
    args: Vec<Value>,
) -> Result<Value, String> {
    if args.is_empty() {
        return Ok(Value::Function(Box::new(FunctionValue::CurriedProp(k))));
    }
    if args.len() > 1 {
        return Err(format!("CurriedProp => expected 0 or 1 arg, got {}", args.len()));
    }
    let obj_val = args.into_iter().next().unwrap();
    match obj_val {
        Value::Placeholder => Ok(Value::Function(Box::new(FunctionValue::CurriedProp(k)))),
        Value::KeyedArray(map) => {
            if let Some(v) = map.get(&k) {
                Ok(v.clone())
            } else {
                Err(format!("CurriedProp => no key '{}' in keyed array", k))
            }
        }
        other => Err(format!(
            "CurriedProp => final object must be keyed array, got {:?}",
            other
        )),
    }
}

pub fn handle_curried_assoc(
    _interp: &mut Interpreter,
    k: String,
    v: Value,
    args: Vec<Value>,
) -> Result<Value, String> {
    if args.is_empty() {
        return Ok(Value::Function(Box::new(FunctionValue::CurriedAssoc(k, v))));
    }
    if args.len() > 1 {
        return Err(format!("CurriedAssoc => expected 1 argument, got {}", args.len()));
    }
    let obj_val = args.into_iter().next().unwrap();
    match obj_val {
        Value::KeyedArray(map) => {
            let mut new_map = map.clone();
            new_map.insert(k, v);
            Ok(Value::KeyedArray(new_map))
        }
        other => Err(format!(
            "CurriedAssoc => final object must be keyed array, got {:?}",
            other
        )),
    }
}

pub fn handle_rust_closure(
    interp: &mut Interpreter,
    desc: String,
    closure_arc: Arc<Mutex<dyn for<'x> Fn(&'x mut Interpreter, Vec<Value>) -> Result<Value, String> + Send + Sync + 'static>>,
    arity: usize,
    args: Vec<Value>,
) -> Result<Value, String> {
    if arity != 0 && args.len() != arity {
        return Err(format!(
            "RustClosure({}): expected {} arg(s), got {}",
            desc, arity, args.len()
        ));
    }
    let lock = closure_arc
        .lock()
        .map_err(|_| format!("Cannot lock RustClosure for '{}'", desc))?;
    lock(interp, args)
}