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 crate::apply::apply_n_ary_function_value;
use mumu::parser::interpreter::Interpreter;
use mumu::parser::types::Value;
use super::common::{is_placeholder, make_two_arg_partial};

pub fn array_take_while_bridge(
    interp: &mut Interpreter,
    args: Vec<Value>,
) -> Result<Value, String> {
    match args.len() {
        0 => Ok(make_two_arg_partial(
            do_take_while,
            None,
            None,
            "array-transform-take_while-partial",
        )),
        1 => {
            if is_placeholder(&args[0]) {
                Ok(make_two_arg_partial(
                    do_take_while,
                    None,
                    None,
                    "array-transform-take_while-partial",
                ))
            } else {
                Ok(make_two_arg_partial(
                    do_take_while,
                    Some(args[0].clone()),
                    None,
                    "array-transform-take_while-partial",
                ))
            }
        }
        2 => {
            let a1_pl = is_placeholder(&args[0]);
            let a2_pl = is_placeholder(&args[1]);
            if !a1_pl && !a2_pl {
                do_take_while(interp, args[0].clone(), args[1].clone())
            } else {
                Ok(make_two_arg_partial(
                    do_take_while,
                    if a1_pl { None } else { Some(args[0].clone()) },
                    if a2_pl { None } else { Some(args[1].clone()) },
                    "array-transform-take_while-partial",
                ))
            }
        }
        _ => Err("array:take_while expects 2 arguments (fn, array)".to_string()),
    }
}

fn do_take_while(interp: &mut Interpreter, pred: Value, arr: Value) -> Result<Value, String> {
    let pred_fn = match pred {
        Value::Function(fb) => fb,
        _ => return Err("array:take_while => first argument must be a function".to_string()),
    };

    match arr {
        Value::IntArray(xs) => {
            let mut out: Vec<i32> = Vec::new();
            for v in xs {
                let keep = apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::Int(v)])?;
                match keep {
                    Value::Bool(true) => out.push(v),
                    _ => break,
                }
            }
            Ok(Value::IntArray(out))
        }
        Value::FloatArray(xs) => {
            let mut out: Vec<f64> = Vec::new();
            for v in xs {
                let keep = apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::Float(v)])?;
                match keep {
                    Value::Bool(true) => out.push(v),
                    _ => break,
                }
            }
            Ok(Value::FloatArray(out))
        }
        Value::StrArray(xs) => {
            let mut out: Vec<String> = Vec::new();
            for s in xs {
                let keep = apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::SingleString(s.clone())])?;
                match keep {
                    Value::Bool(true) => out.push(s),
                    _ => break,
                }
            }
            Ok(Value::StrArray(out))
        }
        Value::BoolArray(xs) => {
            let mut out: Vec<bool> = Vec::new();
            for b in xs {
                let keep = apply_n_ary_function_value(interp, pred_fn.clone(), vec![Value::Bool(b)])?;
                match keep {
                    Value::Bool(true) => out.push(b),
                    _ => break,
                }
            }
            Ok(Value::BoolArray(out))
        }
        Value::MixedArray(xs) => {
            let mut out = Vec::new();
            for v in xs {
                let keep = apply_n_ary_function_value(interp, pred_fn.clone(), vec![v.clone()])?;
                match keep {
                    Value::Bool(true) => out.push(v),
                    _ => break,
                }
            }
            Ok(Value::MixedArray(out))
        }
        other => Err(format!("array:take_while => second argument must be array, got {:?}", other)),
    }
}