toros 0.1.0

Reproducible builds, dev envs and deployments
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

// SPDX-FileCopyrightText: 2022 Kevin Amado <kamadorueda@gmail.com>
//
// SPDX-License-Identifier: AGPL-3.0-only

use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

use crate::interpreter::value::Value;

#[derive(Clone)]
pub(crate) struct Scope {
    kind:     ScopeKind,
    bindings: Rc<RefCell<HashMap<String, Rc<Value>>>>,
    parent:   Option<Box<Scope>>,
}

#[derive(Clone, Debug)]
pub(crate) enum ScopeKind {
    Plain,
}

impl Scope {
    pub(crate) fn empty() -> Scope {
        Scope {
            kind:     ScopeKind::Plain,
            bindings: Rc::new(RefCell::new(HashMap::new())),
            parent:   None,
        }
    }

    pub(crate) fn derive(&self, kind: ScopeKind) -> Scope {
        Scope {
            kind,
            bindings: Rc::new(RefCell::new(HashMap::new())),
            parent: Some(Box::new(self.clone())),
        }
    }

    pub(crate) fn bind(&self, identifier: String, value: Rc<Value>) {
        self.bindings.borrow_mut().insert(identifier, value);
    }

    pub(crate) fn lookup(&self, identifier: &String) -> Option<Rc<Value>> {
        let mut scope = self;

        loop {
            if let Some(value) = scope.bindings.borrow().get(identifier) {
                return Some(value.clone());
            }

            if let Some(parent_scope) = &scope.parent {
                scope = parent_scope;
            } else {
                break;
            }
        }

        None
    }
}

impl std::fmt::Debug for Scope {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Scope {{ kind: {:?}, bindings: {:?} }}",
            self.kind,
            self.bindings.borrow().len()
        )
    }
}