mtots_core 0.1.2

Core implementation of the mtots scripting language
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

use super::*;

pub(super) fn new(iterable: &Rc<Class>) -> Rc<Class> {
    Class::new(
        "Map".into(),
        Class::join_class_maps(
            Class::map_from_funcs(vec![
                NativeFunction::new("len", ["self"], "", |_globals, args, _| {
                    let mut args = args.into_iter();
                    let owner = args.next().unwrap().into_map()?;
                    let owner = owner.borrow();
                    Ok(owner.len().into())
                }),
                NativeFunction::new(
                    "get",
                    ArgSpec::builder()
                        .req("self")
                        .req("key")
                        .def("default", ConstVal::Invalid),
                    "",
                    |_globals, args, _| {
                        let mut args = args.into_iter();
                        let owner = args.next().unwrap().into_map()?;
                        let owner = owner.borrow();
                        let key = Key::try_from(args.next().unwrap())?;
                        let default = args.next().unwrap();
                        if let Some(value) = owner.get(&key) {
                            Ok(value.clone())
                        } else if let Value::Invalid = default {
                            Err(rterr!("Key {:?} not found in map", key))
                        } else {
                            Ok(default)
                        }
                    },
                ),
                NativeFunction::new("has_key", ["self", "key"], "", |_globals, args, _| {
                    let mut args = args.into_iter();
                    let owner = args.next().unwrap().into_map()?;
                    let owner = owner.borrow();
                    let key = Key::try_from(args.next().unwrap())?;
                    Ok(owner.contains_key(&key).into())
                }),
            ]),
            vec![iterable],
        ),
        Class::map_from_funcs(vec![NativeFunction::new(
            "__from_iterable",
            ["iterable"],
            "",
            |globals, args, _| {
                let mut args = args.into_iter();
                let iterable = args.next().unwrap();
                map_from_iterable(globals, iterable)
            },
        )]),
    )
}

fn map_from_iterable(globals: &mut Globals, iter: Value) -> Result<Value> {
    match iter {
        Value::Map(map) => Ok(Value::from(Map::unwrap_or_clone(map))),
        _ => Ok(iter
            .unpack(globals)?
            .into_iter()
            .map(|pair| pair.unpack_keyval(globals))
            .collect::<Result<Map>>()?
            .into()),
    }
}