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

use super::*;

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

    let actual = LispMacro::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 = LispMacro::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 = LispMacro::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 = "(macro (x) (cons x '(x ())))";

    let actual = LispMacro::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 = "(macro)";

    let actual = LispMacro::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_macro() {
    let subject = "(macro";

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