sexprs-parser 0.0.5

sexprs is a minimal lisp dialect to evaluate written 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#![allow(unused)]
use k9::assert_equal;
use sexprs_data_structures::{list, Value};
use sexprs_parser::test::stub_input;
use sexprs_parser::{parse_source, Result};
use sexprs_util::vec_deque;

#[test]
fn test_cons_of_literal_strings() -> Result<'static, ()> {
    // (cons "a" "b")
    let items = parse_source(r#"(cons "a" "b")"#)?;
    assert_equal!(
        items,
        list([
            Value::symbol("cons"),
            Value::from("a"),
            Value::from("b"),
        ])
    );
    Ok(())
}

#[test]
fn test_list_of_literal_strings() -> Result<'static, ()> {
    // (list "a" "b")
    let items = parse_source(r#"(list "a" "b")"#)?;
    assert_equal!(
        items,
        list([
            Value::symbol("list"),
            Value::from("a"),
            Value::from("b"),
        ])
    );
    Ok(())
}

#[test]
fn test_quoted_list_of_literal_strings() -> Result<'static, ()> {
    // (list "a" "b")
    let items = parse_source(r#"'("a" "b")"#)?;
    assert_equal!(items, list([Value::from("a"), Value::from("b"),]).quote());
    Ok(())
}

#[test]
fn test_call_to_function_add_two_numbers() -> Result<'static, ()> {
    // (+ 1 2)
    let items = parse_source(r#"(+ 1 2)"#)?;
    assert_equal!(
        items,
        list([
            Value::symbol("+"),
            Value::unsigned_integer(1u32),
            Value::unsigned_integer(2u32),
        ])
    );
    Ok(())
}

#[test]
fn test_list_of_literal_strings_and_quoted_list_of_literal_strings(
) -> Result<'static, ()> {
    // (list "a" "b" '("b" "c"))
    let items = parse_source(r#"(list "a" "b" '("c" "d"))"#)?;
    assert_equal!(
        items,
        list([
            Value::symbol("list"),
            Value::from("a"),
            Value::from("b"),
            list([
                Value::from("c"),
                Value::from("d"),
            ]).quote(),
        ])
    );
    Ok(())
}

#[test]
fn test_cons_of_car_literal_string_and_cdr_quoted_list_of_literal_strings(
) -> Result<'static, ()> {
    // (cons "a" '("b" "c"))
    let items = parse_source(r#"(cons "a" '("b" "c"))"#)?;
    assert_equal!(
        items,
        list([
            Value::symbol("cons"),
            Value::from("a"),
            list([
                Value::from("b"),
                Value::from("c"),
            ]).quote(),
        ])
    );
    Ok(())
}

#[test]
fn test_print() -> Result<'static, ()> {
    let items = parse_source(r#"(print "t")"#)?;
    assert_equal!(items, list([Value::symbol("print"), Value::from("t")]));
    Ok(())
}

#[test]
fn test_defun() -> Result<'static, ()> {
    // (defun myfun() (cons "a" '("b" "c")))
    let items = parse_source(r#"(defun myfun() (cons "a" '("b" "c")))"#)?;
    assert_equal!(
        items,
        list([
            Value::symbol("defun"),
            Value::symbol("myfun"),
            list([]),
            list([
                Value::symbol("cons"),
                Value::from("a"),
                list([
                    Value::from("b"),
                    Value::from("c"),
                ]).quote()
            ])
        ])
    );
    Ok(())
}