ralix 0.2.0

A simple, type-safe, tree walking interpreter
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

use std::collections::HashMap;

use crate::{Addr, expressions::Identifier};

/// [`Environment`] Scope
pub type EnvScope = HashMap<Identifier, Addr>;

#[derive(Debug, Clone)]
pub struct Environment {
    scopes: Vec<EnvScope>,
}

impl Default for Environment {
    fn default() -> Self {
        Environment {
            scopes: vec![EnvScope::new()],
        }
    }
}

impl Environment {
    pub fn define(&mut self, key: Identifier, value: Addr) -> Option<Addr> {
        if let Some(last_scope) = self.scopes.last_mut()
            && let Some(old_v) = last_scope.insert(key, value)
        {
            return old_v.into();
        }
        None
    }

    /// Drops it if exists
    pub fn drop(&mut self, key: &Identifier) -> Option<Addr> {
        for s in self.scopes.iter_mut().rev() {
            if let Some(val) = s.remove(key) {
                return val.into();
            }
        }
        None
    }

    /// Deep copies the value its holding and returns it
    /// Does not drops the value
    pub fn get_cloned(&self, key: &Identifier) -> Option<Addr> {
        for s in self.scopes.iter().rev() {
            if let Some(val) = s.get(key).cloned() {
                return val.into();
            }
        }
        None
    }

    /// Can be used when changing the already bindings values
    /// `let a = 3; a = 5;` for example
    pub fn get_mut(&mut self, key: &Identifier) -> Option<&mut Addr> {
        for s in self.scopes.iter_mut().rev() {
            if let Some(val) = s.get_mut(key) {
                return val.into();
            }
        }
        None
    }

    /// Returns immutable referance
    pub fn get_ptr(&self, key: &Identifier) -> Option<Addr> {
        for s in self.scopes.iter().rev() {
            if let Some(addr) = s.get(key) {
                return Some(*addr);
            }
        }
        None
    }

    pub fn enter_scope(&mut self) {
        self.scopes.push(EnvScope::new());
    }

    pub fn leave_scope(&mut self) {
        if self.scopes.len() > 1 {
            self.scopes.pop();
        }
    }

    pub fn extend_from(&mut self, other: &EnvScope) {
        for (ident, value) in other {
            self.define(ident.clone(), *value);
        }
    }

    /// Clones the last scope
    pub fn current_items(&self) -> EnvScope {
        let mut result = EnvScope::new();
        for s in self.scopes.clone() {
            for (ident, v) in s {
                result.insert(ident, v);
            }
        }

        result
    }

    pub fn clear(&mut self) {
        self.scopes.clear();
        self.scopes.push(EnvScope::new());
    }
}