parsley 0.10.0

An implementation of Scheme
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

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

use super::{Error, Result, SExp};

/// A type to represent an execution environment.
pub type Ns = HashMap<String, SExp>;

type Link = Option<Rc<Env>>;

#[derive(Debug, Default)]
pub struct Env {
    env: RefCell<Ns>,
    parent: Link,
}

impl Env {
    pub fn new(parent: Link) -> Self {
        Self {
            parent,
            ..Self::default()
        }
    }

    pub fn parent(&self) -> Link {
        self.parent.clone()
    }

    pub fn into_rc(self) -> Rc<Self> {
        Rc::new(self)
    }

    pub fn iter(&self) -> Iter {
        Iter(Some(self))
    }

    pub fn len(&self) -> usize {
        self.parent().into_iter().count() + 1
    }

    pub fn extend(&self, other: Ns) {
        self.env.borrow_mut().extend(other.into_iter());
    }

    pub fn get(&self, key: &str) -> Option<SExp> {
        for ns in self.iter() {
            if let Some(val) = ns.env.borrow().get(key) {
                return Some(val.clone());
            }
        }

        None
    }

    pub fn define(&self, key: &str, val: SExp) {
        self.env.borrow_mut().insert(key.to_string(), val);
    }

    pub fn set(&self, key: &str, val: SExp) -> Result {
        let possible_err = Error::UndefinedSymbol {
            sym: key.to_string(),
        };

        for ns in self.iter() {
            if ns.env.borrow().get(key).is_some() {
                return ns
                    .env
                    .borrow_mut()
                    .insert(key.to_string(), val)
                    .ok_or(possible_err);
            }
        }

        Err(possible_err)
    }
}

pub struct Iter<'a>(Option<&'a Env>);

impl<'a> Iterator for Iter<'a> {
    type Item = &'a Env;

    fn next(&mut self) -> Option<Self::Item> {
        let ret = self.0.take();

        if let Some(rc) = ret {
            if let Some(p) = &rc.parent {
                self.0 = Some(p);
            }
        }

        ret
    }
}

impl IntoIterator for Env {
    type Item = Rc<Self>;
    type IntoIter = IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        IntoIter(Some(self.into_rc()))
    }
}

pub struct IntoIter(Link);

impl Iterator for IntoIter {
    type Item = Rc<Env>;

    fn next(&mut self) -> Option<Self::Item> {
        let ret = self.0.take();

        if let Some(rc) = &ret {
            self.0 = rc.parent();
        }

        ret
    }
}