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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::{
  cell::RefCell,
  fmt::{self, Debug},
  rc::Rc,
};

use crate::environment::Environment;

#[derive(Clone, PartialEq)]
pub enum Object {
  Void,
  Cond,
  Quote(Rc<Object>),
  Keyword(String),
  Native(String),
  Operator(String),
  Float(f64),
  Integer(i64),
  Bool(bool),
  String(String),
  Symbol(String),
  Lambda(Vec<String>, Box<Object>, Rc<RefCell<Environment>>),
  List(Vec<Object>),
}

impl Default for Object {
  fn default() -> Self {
    Object::Void
  }
}

impl Debug for Object {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    match self {
      Object::Void => write!(f, "#nil"),
      Object::Integer(n) => write!(f, "Integer({})", n),
      Object::Float(n) => write!(f, "Float({})", n),
      Object::Bool(b) => {
        if *b {
          write!(f, "#t")
        } else {
          write!(f, "#f")
        }
      }
      Object::String(s) => write!(f, "String({})", s),
      Object::Symbol(s) => write!(f, "Symbol({})", s),
      Object::Keyword(s) => write!(f, "Keyword({})", s),
      Object::Lambda(params, body, _env) => {
        let params_str = params.join(" ");

        write!(f, "Lambda(params: ({}), body: {:?})", params_str, body)
      }
      Object::Native(s) => write!(f, "Native({})", s),
      Object::List(list) => {
        let list_str = list
          .iter()
          .map(|x| format!("{:?}", x))
          .collect::<Vec<String>>()
          .join(", ");

        write!(f, "List({})", list_str)
      }
      Object::Cond => write!(f, "Cond"),
      Object::Quote(o) => write!(f, "Quote({:?})", o),
      Object::Operator(s) => write!(f, "Operator({})", s),
    }
  }
}

impl fmt::Display for Object {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      Object::Void => write!(f, "#nil"),
      Object::Integer(n) => write!(f, "{}", n),
      Object::Bool(b) => {
        if *b {
          write!(f, "#t")
        } else {
          write!(f, "#f")
        }
      }
      Object::Symbol(s) => write!(f, "{}", s),
      Object::Native(s) => write!(f, "{}", s),
      Object::Lambda(params, body, _env) => {
        let params_str = params.join(" ");

        write!(f, "(lambda ({}) {})", params_str, body)
      }
      Object::List(list) => {
        let list_str = list
          .iter()
          .map(|x| format!("{}", x))
          .collect::<Vec<String>>()
          .join(" ");

        write!(f, "({})", list_str)
      }
      Object::Keyword(s) => write!(f, "{}", s),
      Object::Operator(s) => write!(f, "{}", s),
      Object::Float(n) => write!(f, "{}", n),
      Object::String(s) => write!(f, "{}", s),
      Object::Quote(o) => write!(f, "'{}", o),
      Object::Cond => write!(f, "cond"),
    }
  }
}