whiledb 0.1.4

rust implementation of WhileDB 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
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
147
148
149
150
151
152
153
154

use crate::interpreter::*;

/// first get attr from a object
/// 
/// if not exist, get attrs from the type object refed in `__type__` attr
pub fn get_attr(obj: Any, key: &str) -> Option<Any> {
    match &*obj.borrow() {
        WdAny::Obj(obj) => {
            match obj.attrs.get(key) {
                Some(v) => Some(v.clone()),
                None => get_attr(obj.attrs.get("__type__")?.clone(), key)
            }
        },
        _ => None,
    }
}

pub fn get_father_attr(obj: Any, key: &str) -> Option<Any> {
    match &*obj.borrow() {
        WdAny::Obj(obj) => {
            match obj.attrs.get("__type__") {
                Some(t) => get_attr(t.clone(), key),
                None => None
            }
        },
        _ => None,
    }
}

/// just get the attr with no recursive
pub fn get_self_attr(obj: Any, key: &str) -> Option<Any> {
    match &*obj.borrow() {
        WdAny::Obj(obj) => {
            match obj.attrs.get(key) {
                Some(v) => Some(v.clone()),
                None => None
            }
        },
        _ => None,
    }
}

/// get var from local (if not exist nonlocal)
pub fn get_var(name: &str, state: Any) -> Result<Any> {
    match &*state.borrow() {
        WdAny::Obj(obj) => {
            match obj.attrs.get(name) {
                Some(v) => Ok(v.clone()),
                None => match obj.attrs.get("..") {
                    Some(nonlocal) => get_var(name, nonlocal.clone()),
                    None => bail!("Undefined variable `{}`", name)
                }
            }
        },
        _ => unreachable!(),
    }
}

/// get var from the root state
pub fn get_buildin_var(name: &str, state: Any) -> Result<Any> {
    let root = match get_self_attr(state.clone(), "/") {
        Some(root) => root,
        None => state.clone(),
    };
    match get_self_attr(root, name) {
        Some(v) => Ok(v),
        None => bail!("Undefined buildin-variable `{}`", name),
    }
}

/// set attr of a object
pub fn set_attr(obj: Any,  key: &str, val: Any) -> Result<()> {
    match &mut *obj.borrow_mut() {
        WdAny::Obj(obj) => {
            obj.attrs.insert(key.to_string(), val.clone());
            Ok(())
        },
        _ => bail!("Cannot set attr a function")
    }
}

/// call a `Any` function
/// 
/// either function or a object with `__call__` attr
pub fn call(obj: Any, args: VecDeque<Any>, state: Any) -> Result<Any> {
    match &*obj.clone().borrow() {
        WdAny::Obj(_) => {
            match get_self_attr(obj.clone(), "__init__") {
                Some(f) => {
                    let mut args = args;
                    args.push_front(Rc::new(RefCell::new(WdAny::Obj(Object {
                        buildin: BuildIn::Not,
                        attrs: maplit::hashmap! {
                            "__type__".to_string() => obj
                        }
                    }))));
                    call(f, args, state)
                },
                None => match get_self_attr(obj.clone(), "__call__") {
                    Some(f) => call(f, args, state),
                    None => match get_father_attr(obj.clone(), "__call__") {
                        Some(f) => {
                            let mut args = args;
                            args.push_front(obj.clone());
                            call(f, args, state)
                        },
                        None => bail!("cannot call obj")
                    }
                },
            }
        },
        WdAny::Func(_fname, f) => {
            match f {
                Function::BuildInFunction(f) => {
                    (f.0)(args, state)
                },
                Function::DefinedFunction(f) => {
                    let local = local_state(state.clone());
                    for (k, v) in std::iter::zip(f.args.clone(), args) {
                        set_attr(local.clone(), &k, v)?;
                    }
                    let (_, _, ret) = exec(f.body.clone(), local)?;
                    Ok(ret.unwrap_or(get_buildin_var("None", state)?))
                },
            }
        },
    }
}

pub fn local_state(state: Any) -> Any {
    let mut attrs = maplit::hashmap! { "..".to_string() => state.clone() };
    match get_self_attr(state.clone(), "/") {
        Some(root) => attrs.insert("/".to_string(), root),
        None => attrs.insert("/".to_string(), state.clone()),
    };
    let local = Rc::new(RefCell::new(WdAny::Obj(Object{
        buildin: BuildIn::Not,
        attrs: attrs
    })));
    local
}

pub fn convert2string(arg: Any, state: Any) -> Result<String> {
    match utils::get_father_attr(arg.clone(), "__string__") {
        Some(f) => {
            let s = utils::call(f, VecDeque::from([arg]), state.clone())?;
            match obj_string::any2string(s) {
                Some(s) => Ok(s),
                None => unreachable!(),
            }
        },
        None => bail!("converting an object that cannot convert to string"),
    }
}