tulisp 0.29.0

An embeddable lisp interpreter.
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
141
142
143
144
145
146
147
148
149

#![doc = include_str!("../README.md")]

pub(crate) mod bytecode;
mod eval;
mod macros;
mod parse;

pub mod builtin;

mod cons;
pub use cons::{BaseIter, Iter};

mod context;
pub use context::{Rest, TulispContext};

mod error;
pub use error::{Error, ErrorKind};

pub mod alist;
pub use alist::{Alistable, alist_from, alist_get, assoc};

pub mod lists;

pub mod plist;
pub use plist::{Plist, Plistable, plist_from, plist_get};

mod number;
pub use number::Number;

mod value;
pub use value::TulispAny;
#[doc(hidden)]
pub use value::TulispValue;
#[doc(hidden)]
pub use value::debug_lex_stacks_total;

mod object;
pub use {
    object::TulispObject, object::conversions::TulispConvertible,
    object::wrappers::generic::Shared, object::wrappers::generic::SharedMut,
};

#[cfg(test)]
mod test_utils {
    /// A pair of evaluators for the same source string, run on the
    /// same `TulispContext` so any test setup (defuns, defvars,
    /// etc.) on the ctx is visible to both. Each helper below runs
    /// its assertion through `EvalKind::Tw` first and then
    /// `EvalKind::Vm`, so a behavioral divergence between paths
    /// surfaces as a panic naming the path.
    #[derive(Copy, Clone)]
    enum EvalKind {
        Tw,
        Vm,
    }

    impl EvalKind {
        fn name(self) -> &'static str {
            match self {
                EvalKind::Tw => "TW",
                EvalKind::Vm => "VM",
            }
        }
    }

    #[track_caller]
    fn eval_string(
        ctx: &mut crate::TulispContext,
        kind: EvalKind,
        s: &str,
    ) -> Result<crate::TulispObject, String> {
        let res = match kind {
            EvalKind::Tw => ctx.tw_eval_string(s),
            EvalKind::Vm => ctx.eval_string(s),
        };
        res.map_err(|e| e.format(ctx))
    }

    #[track_caller]
    fn must_eval_string(
        ctx: &mut crate::TulispContext,
        kind: EvalKind,
        s: &str,
    ) -> crate::TulispObject {
        match eval_string(ctx, kind, s) {
            Ok(t) => t,
            Err(e) => panic!("[{}] {}", kind.name(), e),
        }
    }

    #[track_caller]
    pub(crate) fn eval_assert_equal(ctx: &mut crate::TulispContext, a: &str, b: &str) {
        for kind in [EvalKind::Tw, EvalKind::Vm] {
            let av = must_eval_string(ctx, kind, a);
            let bv = must_eval_string(ctx, kind, b);
            assert!(
                crate::TulispObject::equal(&av, &bv),
                "[{}] {}(=> {}) != {}(=> {})",
                kind.name(),
                a,
                av,
                b,
                bv
            );
        }
    }

    #[track_caller]
    pub(crate) fn eval_assert(ctx: &mut crate::TulispContext, a: &str) {
        for kind in [EvalKind::Tw, EvalKind::Vm] {
            let av = must_eval_string(ctx, kind, a);
            assert!(
                av.is_truthy(),
                "[{}] {}(=> {}) is not true",
                kind.name(),
                a,
                av
            );
        }
    }

    #[track_caller]
    pub(crate) fn eval_assert_not(ctx: &mut crate::TulispContext, a: &str) {
        for kind in [EvalKind::Tw, EvalKind::Vm] {
            let av = must_eval_string(ctx, kind, a);
            assert!(av.null(), "[{}] {}(=> {}) is not nil", kind.name(), a, av);
        }
    }

    #[track_caller]
    pub(crate) fn eval_assert_error(ctx: &mut crate::TulispContext, a: &str, msg: &str) {
        // Both paths must match `msg` exactly. The VM emits
        // `PushTrace` / `PopTrace` instructions around every list
        // form, which gives errors the same multi-level trace shape
        // TW's recursive `eval_basic` produces.
        for kind in [EvalKind::Tw, EvalKind::Vm] {
            match eval_string(ctx, kind, a) {
                Ok(v) => panic!("[{}] Expected error but got {} for {}", kind.name(), v, a),
                Err(e) => assert_eq!(
                    e.to_string(),
                    msg,
                    "[{}] Error message mismatch for {}",
                    kind.name(),
                    a
                ),
            }
        }
    }
}