lispexp 0.1.1

A pure-Rust reader (lexer + parser) for S-expression syntax across many Lisp dialects
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

//! Reader tests for the Racket dialect.

use lispexp::{parse, Datum, DatumKind, Delim, Options, Parsed, Prefix};

fn rkt(src: &str) -> Vec<Datum<'_>> {
    let parsed = parse(src, &Options::racket());
    assert!(
        parsed.errors.is_empty(),
        "unexpected errors: {:?}",
        parsed.errors
    );
    parsed.data
}

fn rkt_parsed(src: &str) -> Parsed<'_> {
    parse(src, &Options::racket())
}

#[test]
fn lang_line_is_captured_not_a_datum() {
    let parsed = rkt_parsed("#lang racket/base\n(define x 1)");
    assert_eq!(parsed.lang_line, Some("racket/base"));
    // The `#lang` line is not a datum; only the definition is.
    assert_eq!(parsed.data.len(), 1);
    assert!(matches!(parsed.data[0].kind, DatumKind::List { .. }));
    assert!(parsed.errors.is_empty());
}

#[test]
fn shebang_then_lang() {
    let parsed = rkt_parsed("#!/usr/bin/env racket\n#lang racket\n(+ 1 2)");
    assert_eq!(parsed.lang_line, Some("racket"));
    assert_eq!(parsed.data.len(), 1);
}

#[test]
fn hash_colon_keywords() {
    let data = rkt("(f #:width 10 #:height 20)");
    let DatumKind::List { items, .. } = &data[0].kind else {
        panic!()
    };
    assert_eq!(items[1].kind, DatumKind::Keyword("#:width"));
    assert_eq!(items[3].kind, DatumKind::Keyword("#:height"));
}

#[test]
fn brackets_and_braces_are_lists() {
    let data = rkt("(let ([x 1] {y 2}) x)");
    let DatumKind::List { items, .. } = &data[0].kind else {
        panic!()
    };
    let DatumKind::List { items: binds, .. } = &items[1].kind else {
        panic!()
    };
    let DatumKind::List { delim: d0, .. } = &binds[0].kind else {
        panic!()
    };
    let DatumKind::List { delim: d1, .. } = &binds[1].kind else {
        panic!()
    };
    assert_eq!(*d0, Delim::Square);
    assert_eq!(*d1, Delim::Curly);
}

#[test]
fn syntax_quote() {
    let data = rkt("#'(lambda (x) x)");
    assert!(matches!(
        data[0].kind,
        DatumKind::Prefixed {
            prefix: Prefix::VarQuote,
            ..
        }
    ));
}

#[test]
fn vector_forms() {
    // `#(...)`, `#[...]`, `#{...}` are all vector literals.
    let data = rkt("#(1 2) #[3 4] #{5 6}");
    for d in &data {
        let DatumKind::HashLiteral { tag, inner } = &d.kind else {
            panic!("expected vector, got {:?}", d.kind)
        };
        assert_eq!(*tag, "");
        assert!(matches!(
            inner.as_ref().unwrap().kind,
            DatumKind::List { .. }
        ));
    }
}

#[test]
fn booleans_and_chars() {
    let data = rkt(r"#t #f #\a #\newline");
    assert_eq!(
        data.iter().map(|d| &d.kind).collect::<Vec<_>>(),
        vec![
            &DatumKind::Bool(true),
            &DatumKind::Bool(false),
            &DatumKind::Char(r"#\a"),
            &DatumKind::Char(r"#\newline"),
        ]
    );
}

#[test]
fn datum_comment_and_block_comment() {
    let data = rkt("(a #;b c #| block |# d)");
    let DatumKind::List { items, .. } = &data[0].kind else {
        panic!()
    };
    // `#;b` discards `b`; the block comment is skipped.
    assert_eq!(
        items.iter().map(|d| &d.kind).collect::<Vec<_>>(),
        vec![
            &DatumKind::Symbol("a"),
            &DatumKind::Symbol("c"),
            &DatumKind::Symbol("d"),
        ]
    );
}

#[test]
fn no_lang_line_when_absent() {
    let parsed = rkt_parsed("(+ 1 2)");
    assert_eq!(parsed.lang_line, None);
}