oftlisp 0.1.3

A compiler and interpreter for OftLisp, 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
129
130
131
132
133
134
135
136
137
138
139

//! Macro expansion's implementation.

use either::{Either, Left, Right};
use gc::Gc;

use ast::{ConvertError, convert_fn, Expr};
use collections::GcLinkedList;
use context::InterpreterContext;
use symbol::Symbol;
use util::{as_list, as_shl};
use value::Value;

/// Performs macro-expansion on a module.
pub fn expand_module<C: 'static + InterpreterContext>(
    body: Vec<Gc<Value<C>>>,
    env: &mut GcLinkedList<(Symbol, Gc<Value<C>>)>,
    menv: &mut GcLinkedList<(Symbol, Gc<Value<C>>)>,
) -> Result<Vec<Gc<Value<C>>>, Either<C::RuntimeError, ConvertError<C>>> {
    let mut out = vec![];
    for v in body {
        let v = match expand_expr(v, env, menv) {
            Ok(Some(v)) => v,
            Ok(None) => continue,
            Err(err) => return Err(err),
        };
        out.extend(expand_macro_progns(v));
    }
    Ok(out)
}

/// Performs macro-expansion on a single expression.
pub fn expand_expr<C: 'static + InterpreterContext>(
    value: Gc<Value<C>>,
    env: &mut GcLinkedList<(Symbol, Gc<Value<C>>)>,
    menv: &mut GcLinkedList<(Symbol, Gc<Value<C>>)>,
) -> Result<Option<Gc<Value<C>>>, Either<C::RuntimeError, ConvertError<C>>> {
    if let Some((sym, rest)) = as_shl(value.clone()) {
        if sym.as_str() == "defmacro" {
            if rest.len() > 2 {
                let mut body = expand_list(rest, &mut env.clone(), &mut menv.clone())?;

                let name = if let Value::Symbol(name, _) = *body.remove(0) {
                    name
                } else {
                    unimplemented!("invalid defmacro")
                };
                let args = body.remove(0);
                let lambda = convert_fn(Some(name), args, body).map_err(Right)?;
                let lambda = C::from_expr(lambda);

                let func = C::eval(lambda, env).map_err(Left)?;
                menv.push((name, func));
                Ok(None)
            } else {
                unimplemented!("defmacro")
            }
        } else if let Some(mac) = menv.lookup(sym) {
            let args = rest.into_iter().map(Expr::Literal).map(Gc::new).collect();
            let call = Gc::new(Expr::Call(Gc::new(Expr::Literal(mac)), args));
            let call = C::from_expr(call);
            let val = C::eval(call, env).map_err(Left)?;
            expand_expr(val, env, menv)
        } else {
            expand_list(rest, env, menv)
                .map(|l| {
                    let tl = Value::list(l, Default::default());
                    let hd = Gc::new(Value::Symbol(sym, Default::default()));
                    Gc::new(Value::Cons(hd, tl, Default::default()))
                })
                .map(Some)
        }
    } else if let Some(l) = as_list(value.clone()) {
        expand_list(l, env, menv)
            .map(|l| Value::list(l, Default::default()))
            .map(Some)
    } else if let Value::Vector(ref v, _) = *value.clone() {
        expand_list(v.clone(), env, menv).map(Value::vector).map(
            Some,
        )
    } else {
        Ok(Some(value))
    }
}

/// Performs macro-expansion on each element of a list, properly restoring the
/// list's metadata afterwards.
fn expand_list<C: 'static + InterpreterContext>(
    vals: Vec<Gc<Value<C>>>,
    env: &mut GcLinkedList<(Symbol, Gc<Value<C>>)>,
    menv: &mut GcLinkedList<(Symbol, Gc<Value<C>>)>,
) -> Result<Vec<Gc<Value<C>>>, Either<C::RuntimeError, ConvertError<C>>> {
    let mut menv = menv.clone();
    vals.into_iter()
        .filter_map(|v| match expand_expr(v, env, &mut menv) {
            Ok(Some(v)) => Some(Ok(v)),
            Ok(None) => None,
            Err(err) => Some(Err(err)),
        })
        .collect()
}

/// Recursively expands `macro-progn` forms.
///
/// When a macro returns a `macro-progn`, it is expanded into multiple forms in
/// the *current* scope, rather than creating a new scope. For example,
///
/// ```oftlisp
/// (defmacro m ()
///   '(macro-progn
///     (def x 1)
///     (def y 2)))
///
/// (defn main ()
///   (def x 3)
///   (def y 4)
///   (m)
///   (println x ", " y))
/// ```
///
/// will print `1, 2` rather than `3, 4`.
fn expand_macro_progns<C: 'static + InterpreterContext>(value: Gc<Value<C>>) -> Vec<Gc<Value<C>>> {
    fn helper<C: 'static + InterpreterContext>(value: Gc<Value<C>>, v: &mut Vec<Gc<Value<C>>>) {
        if let Some((sym, rest)) = as_shl(value.clone()) {
            if sym == "macro-progn".into() {
                for value in rest {
                    helper(value, v);
                }
            } else {
                v.push(value);
            }
        } else {
            v.push(value);
        }
    }

    let mut out = vec![];
    helper(value, &mut out);
    out
}