array-mumu 0.2.0-rc.5

Array tools plugin for the Mumu ecosystem
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

use mumu::parser::types::Value;
use mumu::parser::interpreter::Interpreter;
use crate::apply::apply_n_ary_function_value;
use super::common::{is_placeholder, make_two_arg_partial};

pub fn array_partition_bridge(interp: &mut Interpreter, args: Vec<Value>) -> Result<Value, String> {
    match args.len() {
        2 => {
            let pred_fn = &args[0];
            let arr = &args[1];
            let pred_pl = is_placeholder(pred_fn);
            let arr_pl = is_placeholder(arr);
            if !pred_pl && !arr_pl {
                do_partition(interp, pred_fn.clone(), arr.clone())
            } else {
                Ok(make_two_arg_partial(
                    do_partition,
                    if pred_pl { None } else { Some(pred_fn.clone()) },
                    if arr_pl { None } else { Some(arr.clone()) },
                    "array-transform-partition-partial",
                ))
            }
        }
        1 => Ok(make_two_arg_partial(
            do_partition,
            Some(args[0].clone()),
            None,
            "array-transform-partition-partial",
        )),
        0 => Ok(make_two_arg_partial(
            do_partition,
            None,
            None,
            "array-transform-partition-partial",
        )),
        n => Err(format!(
            "array:partition => expects 2 arguments (fn, array), got {}",
            n
        )),
    }
}

fn do_partition(
    interp: &mut Interpreter,
    pred_fn_val: Value,
    arr_val: Value,
) -> Result<Value, String> {
    let pred_fn = match pred_fn_val {
        Value::Function(f) => f,
        other => {
            return Err(format!(
                "array:partition => first argument must be a function, got {:?}",
                other
            ))
        }
    };

    match arr_val {
        Value::IntArray(xs) => {
            let mut yes: Vec<i32> = Vec::new();
            let mut no: Vec<i32> = Vec::new();
            for v in xs {
                match apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::Int(v)]) {
                    Ok(Value::Bool(true)) => yes.push(v),
                    _ => no.push(v),
                }
            }
            Ok(Value::MixedArray(vec![Value::IntArray(yes), Value::IntArray(no)]))
        }
        Value::FloatArray(xs) => {
            let mut yes: Vec<f64> = Vec::new();
            let mut no: Vec<f64> = Vec::new();
            for v in xs {
                match apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::Float(v)]) {
                    Ok(Value::Bool(true)) => yes.push(v),
                    _ => no.push(v),
                }
            }
            Ok(Value::MixedArray(vec![Value::FloatArray(yes), Value::FloatArray(no)]))
        }
        Value::StrArray(xs) => {
            let mut yes: Vec<String> = Vec::new();
            let mut no: Vec<String> = Vec::new();
            for s in xs {
                match apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::SingleString(s.clone())]) {
                    Ok(Value::Bool(true)) => yes.push(s),
                    _ => no.push(s),
                }
            }
            Ok(Value::MixedArray(vec![Value::StrArray(yes), Value::StrArray(no)]))
        }
        Value::BoolArray(xs) => {
            let mut yes: Vec<bool> = Vec::new();
            let mut no: Vec<bool> = Vec::new();
            for b in xs {
                match apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::Bool(b)]) {
                    Ok(Value::Bool(true)) => yes.push(b),
                    _ => no.push(b),
                }
            }
            Ok(Value::MixedArray(vec![Value::BoolArray(yes), Value::BoolArray(no)]))
        }
        Value::MixedArray(xs) => {
            let mut yes = Vec::new();
            let mut no = Vec::new();
            for v in xs {
                match apply_n_ary_function_value(interp, pred_fn.clone(), vec![v.clone()]) {
                    Ok(Value::Bool(true)) => yes.push(v),
                    _ => no.push(v),
                }
            }
            Ok(Value::MixedArray(vec![Value::MixedArray(yes), Value::MixedArray(no)]))
        }
        other => Err(format!("array:partition => unsupported array type: {:?}", other)),
    }
}