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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use super::*;

#[test]
pub fn gets_correct_args_and_def_when_function_made_from_sxref() {
    let subject = SXRef::from(vec![
        SXRef::symbol("FAKE LAMBDA".into()),
        SXRef::from(vec![SXRef::symbol("a".into()), SXRef::symbol("b".into())]),
        SXRef::number(2),
    ]);

    let actual = LispFunction::from(subject);

    assert_eq!(
        &vec!["a".to_owned(), "b".to_owned()],
        actual.args()
    );

    assert_eq!(SXRef::number(2), actual.definition())
}

#[test]
pub fn args_is_none_when_passed_sxref_with_non_list_args() {
    let subject = SXRef::from(vec![
        SXRef::symbol("FAKE LAMBDA".into()),
        SXRef::number(1),
        SXRef::number(2),
    ]);

    let actual = LispFunction::from(subject);
    let expected: Vec<String> = Vec::new();

    assert_eq!(&expected, actual.args());

    assert_eq!(SXRef::number(2), actual.definition())
}

#[test]
pub fn args_is_none_when_passed_sxref_with_nil_args() {
    let subject = SXRef::from(vec![
        SXRef::symbol("FAKE LAMBDA".into()),
        SXRef::nil(),
        SXRef::number(2),
    ]);

    let actual = LispFunction::from(subject);
    let expected: Vec<String> = Vec::new();

    assert_eq!(&expected, actual.args());

    assert_eq!(SXRef::number(2), actual.definition())
}

#[test]
pub fn from_string_works() {
    let subject = "(lambda (x) (cons x '(x ())))";

    let actual = LispFunction::try_from(subject).unwrap();

    assert_eq!(&vec!["x".to_owned()], actual.args());

    assert_eq!(
        SXRef::from(vec![
            SXRef::symbol("cons".into()),
            SXRef::symbol("x".into()),
            SXRef::from(vec![
                SXRef::symbol("quote".into()),
                SXRef::from(vec![
                    SXRef::symbol("x".into()),
                    SXRef::nil(),
                ]),
            ]),
        ]),
        actual.definition()
    )
}

#[test]
pub fn str_that_are_missing_args_work() {
    let subject = "(lambda)";

    let actual = LispFunction::try_from(subject).unwrap();
    let empty: Vec<String> = Vec::new();

    assert_eq!(&empty, actual.args());

    assert_eq!(SXRef::nil(), actual.definition())
}


#[test]
#[should_panic]
pub fn bad_lisp_fails_to_become_function() {
    let subject = "(lambda";

    LispFunction::try_from(subject).unwrap();
}

#[test]
pub fn execute_works() {
    let subject = "(lambda (x) x)";
    let subject = LispFunction::try_from(subject).unwrap();

    let args = vec![
        SXRef::number(1),
    ];

    let expected = SXRef::number(1);

    let actual = subject.execute(args, &mut Env::new()).unwrap();

    assert_eq!(expected, actual);
}

#[test]
fn args_returns_list_of_args() {
    let subject = LispFunction::new(
        vec!["x".into(), "y".into()],
        SXRef::nil(),
    );

    let expected: Vec<String> = vec!["x".into(), "y".into()];

    let actual = subject.args();

    assert_eq!(&expected, actual);
}

#[test]
fn definition_returns_lambda_definition() {
    let subject = LispFunction::new(
        Vec::new(),
        SXRef::number(1),
    );

    let expected = SXRef::number(1);

    let actual = subject.definition();

    assert_eq!(expected, actual);
}