scheme4r 0.2.3

Scheme interpreter for 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

use scheme4r::{eval, Value};

#[test]
fn define_syntax_when_expands_and_runs() {
    let value = eval(
        "\
        (define x 0)
        (define-syntax when
          (syntax-rules ()
            ((_ test body ...)
             (if test (begin body ...)))))
        (when #t
          (set! x 41)
          (set! x (+ x 1)))
        x
        ",
    )
    .unwrap();

    assert!(matches!(value, Value::Number(42)));
}

#[test]
fn syntax_rules_support_recursive_variadic_macros() {
    let value = eval(
        "\
        (define-syntax and
          (syntax-rules ()
            ((_ ) #t)
            ((_ x) x)
            ((_ x y ...) (if x (and y ...) x))))
        (and #t 1 2 3)
        ",
    )
    .unwrap();

    assert!(matches!(value, Value::Number(3)));
}

#[test]
fn syntax_rules_support_literal_identifiers() {
    let value = eval(
        "\
        (define-syntax my-cond
          (syntax-rules (else)
            ((_ (else expr)) expr)
            ((_ (test expr) rest ...)
             (if test expr (my-cond rest ...)))))
        (my-cond ((> 1 2) 11) (else 99))
        ",
    )
    .unwrap();

    assert!(matches!(value, Value::Number(99)));
}

#[test]
fn macros_can_expand_into_bindings_and_lists() {
    let value = eval(
        "\
        (define-syntax push-front
          (syntax-rules ()
            ((_ item lst)
             (set! lst (cons item lst)))))
        (define values '(2 3))
        (push-front 1 values)
        values
        ",
    )
    .unwrap();

    assert_eq!(format!("{value}"), "(1 2 3)");
}

#[test]
fn let_syntax_creates_local_macro_scope() {
    let value = eval(
        "\
        (let-syntax
          ((swap
             (syntax-rules ()
               ((_ a b)
                (let ((tmp a))
                  (set! a b)
                  (set! b tmp))))))
          (let ((x 1) (y 2))
            (swap x y)
            (list x y)))
        ",
    )
    .unwrap();

    assert_eq!(format!("{value}"), "(2 1)");
    assert!(eval("(swap 1 2)").is_err());
}

#[test]
fn letrec_syntax_supports_local_recursive_macros() {
    let value = eval(
        "\
        (letrec-syntax
          ((my-or
             (syntax-rules ()
               ((_ ) #f)
               ((_ x) x)
               ((_ x y ...) (let ((tmp x)) (if tmp tmp (my-or y ...)))))))
          (my-or #f #f 7 #f))
        ",
    )
    .unwrap();

    assert!(matches!(value, Value::Number(7)));
}