zuzu-rust 0.6.0

Rust implementation of ZuzuScript
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

use crate::{Result, ZuzuRustError};

use super::super::{Runtime, Value};
use super::common::{
    collection_product, collection_sum, expect_function, make_iterator, require_arity, stored_arg,
    unique_values, CollectionTarget,
};

impl Runtime {
    pub(in crate::runtime) fn call_bag_method(
        &self,
        values: &mut Vec<Value>,
        name: &str,
        args: &[Value],
    ) -> Result<Value> {
        match name {
            "add" | "push" => {
                values.extend(args.iter().cloned().map(Value::into_shared_if_composite));
                Ok(Value::Bag(values.clone()))
            }
            "add_weak" | "push_weak" => {
                values.extend(args.iter().map(|value| stored_arg(value, true)));
                Ok(Value::Bag(values.clone()))
            }
            "copy" => {
                require_arity(name, args, 0)?;
                Ok(Value::Bag(values.clone()))
            }
            "remove" => {
                require_arity(name, args, 1)?;
                values.retain(|value| !value.strict_eq(&args[0]));
                Ok(Value::Bag(values.clone()))
            }
            "remove_first" => {
                require_arity(name, args, 1)?;
                let mut removed = false;
                values.retain(|value| {
                    if !removed && value.strict_eq(&args[0]) {
                        removed = true;
                        false
                    } else {
                        true
                    }
                });
                Ok(Value::Bag(values.clone()))
            }
            "length" => {
                require_arity(name, args, 0)?;
                Ok(Value::Number(values.len() as f64))
            }
            "count" => {
                if args.is_empty() {
                    return Ok(Value::Number(values.len() as f64));
                }
                require_arity(name, args, 1)?;
                Ok(Value::Number(
                    values
                        .iter()
                        .filter(|value| value.strict_eq(&args[0]))
                        .count() as f64,
                ))
            }
            "empty" | "is_empty" => {
                require_arity(name, args, 0)?;
                Ok(Value::Boolean(values.is_empty()))
            }
            "clear" => {
                require_arity(name, args, 0)?;
                values.clear();
                Ok(Value::Bag(values.clone()))
            }
            "contains" => {
                require_arity(name, args, 1)?;
                Ok(Value::Boolean(
                    values.iter().any(|value| value.strict_eq(&args[0])),
                ))
            }
            "to_Array" => {
                require_arity(name, args, 0)?;
                Ok(Value::Array(values.clone()))
            }
            "to_Set" | "uniq" => {
                require_arity(name, args, 0)?;
                Ok(Value::Set(unique_values(values)))
            }
            "to_Iterator" => {
                require_arity(name, args, 0)?;
                Ok(make_iterator(values.clone()))
            }
            "sum" => {
                require_arity(name, args, 0)?;
                Ok(Value::Number(collection_sum(values)?))
            }
            "product" => {
                require_arity(name, args, 0)?;
                Ok(Value::Number(collection_product(values)?))
            }
            "sort" => {
                let mut out = values.clone();
                self.call_array_method(&mut out, "sort", args)
            }
            "sortstr" => {
                let mut out = values.clone();
                self.call_array_method(&mut out, "sortstr", args)
            }
            "sortnum" => {
                let mut out = values.clone();
                self.call_array_method(&mut out, "sortnum", args)
            }
            "map" => self.map_values(values, args, "map", CollectionTarget::Bag),
            "grep" => self.filter_values(values, args, "grep", CollectionTarget::Bag),
            "any" => self.any_values(values, args),
            "all" => self.all_values(values, args),
            "first" => self.first_value(values, args),
            "remove_if" => {
                require_arity(name, args, 1)?;
                let pred =
                    expect_function(&args[0], "Collection method expects a function callback")?;
                values.retain(|value| {
                    !self
                        .predicate_callback(&pred, value.clone())
                        .unwrap_or(false)
                });
                Ok(Value::Bag(values.clone()))
            }
            "for_each_value" => {
                require_arity(name, args, 1)?;
                let func =
                    expect_function(&args[0], "Collection method expects a function callback")?;
                for value in values.iter().cloned() {
                    let _ = self.call_function(&func, vec![value], Vec::new())?;
                }
                Ok(Value::Bag(values.clone()))
            }
            other => Err(ZuzuRustError::thrown(format!(
                "unsupported Bag method '{}'",
                other
            ))),
        }
    }
}