zen-expression 2.0.1

Zen Expression 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

use crate::variable::Variable;
use smallvec::SmallVec;
use zen_types::symbol::Symbol;

#[derive(Debug, Clone)]
pub struct Scope {
    base: Variable,
    locals: SmallVec<[(Symbol, Variable); 4]>,
}

impl Default for Scope {
    fn default() -> Self {
        Self::new(Variable::Null)
    }
}

impl Scope {
    pub fn new(base: Variable) -> Self {
        Self {
            base,
            locals: SmallVec::new(),
        }
    }

    pub fn base(&self) -> &Variable {
        &self.base
    }

    pub fn base_mut(&mut self) -> &mut Variable {
        &mut self.base
    }

    pub fn set_base(&mut self, base: Variable) {
        self.base = base;
        self.locals.clear();
    }

    pub fn locals(&self) -> &[(Symbol, Variable)] {
        &self.locals
    }

    pub fn clear_locals(&mut self) {
        self.locals.clear();
    }

    pub fn set_local(&mut self, name: Symbol, value: Variable) {
        match self
            .locals
            .iter_mut()
            .find(|(key, _)| key.as_str() == name.as_str())
        {
            Some(slot) => slot.1 = value,
            None => self.locals.push((name, value)),
        }
    }

    pub fn local(&self, name: &Symbol) -> Option<&Variable> {
        self.locals
            .iter()
            .find(|(key, _)| key.as_str() == name.as_str())
            .map(|(_, value)| value)
    }

    pub fn local_str(&self, name: &str) -> Option<&Variable> {
        self.locals
            .iter()
            .find(|(key, _)| key.as_str() == name)
            .map(|(_, value)| value)
    }

    pub fn get_str(&self, name: &str) -> Option<Variable> {
        if let Some(value) = self.local_str(name) {
            return Some(value.clone());
        }

        match &self.base {
            Variable::Object(object) => object.borrow().get_str(name).cloned(),
            _ => None,
        }
    }

    pub fn get(&self, name: &Symbol) -> Option<Variable> {
        if let Some(value) = self.local(name) {
            return Some(value.clone());
        }

        match &self.base {
            Variable::Object(object) => object.borrow().get(name).cloned(),
            _ => None,
        }
    }

    pub fn materialize(&self) -> Variable {
        if self.locals.is_empty() {
            return self.base.shallow_clone();
        }

        let Variable::Object(base) = &self.base else {
            return self.base.shallow_clone();
        };

        let mut map = base.borrow().clone();
        for (key, value) in &self.locals {
            map.insert(key.clone(), value.clone());
        }

        Variable::from_object(map)
    }
}

impl From<Variable> for Scope {
    fn from(value: Variable) -> Self {
        Scope::new(value)
    }
}