tlisp 0.0.2

Lisp interpreter in Rust
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

use crate::{object::Object, runtime};
use std::{cell::RefCell, collections::HashMap, fmt, rc::Rc};

#[derive(Debug)]
pub struct Environment {
  parent: Option<Rc<RefCell<Environment>>>,
  vars: HashMap<String, Object>,
  runtime: runtime::Runtime,
}

impl PartialEq for Environment {
  fn eq(&self, other: &Self) -> bool {
    self.vars == other.vars
  }
}

impl Environment {
  pub fn new(runtime: runtime::Runtime) -> Self {
    Environment {
      parent: None,
      vars: HashMap::new(),
      runtime,
    }
  }

  pub fn extend(parent: Rc<RefCell<Self>>) -> Environment {
    let runtime = parent.borrow().runtime.clone();
    Environment {
      vars: HashMap::new(),
      parent: Some(parent),
      runtime,
    }
  }

  pub fn get_runtime_fn(&self, name: &str) -> Option<Rc<runtime::RuntimeFn>> {
    let runtime = self.runtime.clone();

    match runtime.get_method(name) {
      Some(f) => Some(f.clone()),
      None => None,
    }
  }

  pub fn get(&self, name: &str) -> Option<Object> {
    match self.vars.get(name) {
      Some(value) => Some(value.clone()),
      None => self.parent.as_ref().and_then(|o| o.borrow().get(name)),
    }
  }

  pub fn set(&mut self, name: &str, val: Object) {
    self.vars.insert(name.to_string(), val);
  }

  pub fn update(&mut self, data: Rc<RefCell<Self>>) {
    self.vars.extend(
      data
        .borrow()
        .vars
        .iter()
        .map(|(k, v)| (k.clone(), v.clone())),
    );
  }
}

impl fmt::Display for Environment {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    let mut vars_str = String::new();

    for (k, v) in self.vars.iter() {
      vars_str.push_str(&format!("{}: {}\n", k, v));
    }

    let _ = match self.parent {
      Some(ref parent) => {
        vars_str.push_str(&format!("parent: {}\n", parent.borrow()));
      }
      None => {
        vars_str.push_str("parent: None\n");
      }
    };

    write!(f, "{}", vars_str)
  }
}