nyavascript 0.1.0

Lisp implementation. Called NyavaScript because I'm a monster
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

mod cons_cell;
pub use cons_cell::ConsCell;

pub mod function;
pub use function::*;

mod r#macro;
pub use r#macro::*;

mod s_expression_ref;
pub use s_expression_ref::{ SExpressionRef, ListIter };

pub mod util;

#[derive(Clone, Debug, PartialEq)]
pub enum SExpression {
    ConsCell(ConsCell),
    Function(Function),
    Macro(Macro),
    Nil,
    Number(isize),
    Quote(SExpressionRef),
    String(String),
    Symbol(String),
}

impl std::fmt::Display for SExpression {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            SExpression::ConsCell(x) => write!(f, "{}", x),
            SExpression::Number(x) => write!(f, "{}", x),
            SExpression::String(x) => write!(f, "\"{}\"", x),
            SExpression::Symbol(x) => write!(f, "{}", x),
            SExpression::Nil => write!(f, "NIL"),
            SExpression::Function(x) => write!(f, "{}", x),
            SExpression::Macro(x) => write!(f, "{}", x),
            SExpression::Quote(x) => write!(f, "'{}", x),
        }
    }
}

impl SExpression {
    pub fn as_cons_cell(&self) -> Option<&ConsCell> {
        match self {
            Self::ConsCell(c) => Some(c),
            _ => None,
        }
    }

    pub fn as_symbol(&self) -> Option<&str> {
        match self {
            Self::Symbol(s) => Some(s),
            _ => None,
        }
    }

    pub fn from_iter<I: IntoIterator<Item=SExpressionRef>>(i: I) -> SExpressionRef {
        let mut ret = SExpressionRef::nil();

        // Probably a more efficient way to do this, but since cons aren't
        // double ended, just convert them to vecs for now
        for valref in i.into_iter().collect::<Vec<SExpressionRef>>().iter().rev() {
            ret = util::cons(valref, &ret);
        }

        ret
    }

    pub fn is_cons_cell(&self) -> bool {
        matches!(self, Self::ConsCell(_))
    }

    pub fn is_nil(&self) -> bool {
        matches!(self, Self::Nil)
    }
}


impl From<ConsCell> for SExpression {
    fn from(c: ConsCell) -> Self {
        Self::ConsCell(c)
    }
}

impl From<Function> for SExpression {
    fn from(f: Function) -> Self {
        Self::Function(f)
    }
}

impl From<Macro> for SExpression {
    fn from(f: Macro) -> Self {
        Self::Macro(f)
    }
}

impl From<Vec<SExpressionRef>> for SExpression {
    fn from(v: Vec<SExpressionRef>) -> Self {
        let mut ret = SExpression::Nil;

        for e in v.into_iter().rev() {
            ret = SExpression::ConsCell(ConsCell::new(
                e,
                SExpressionRef::new(ret),
            ));
        }

        ret
    }
}