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
140
141
142
143
144
145
146

//! Utility functions.

use std::collections::HashMap;

use gc::{Gc, Trace};

use context::Context;
use symbol::Symbol;
use value::Value;

/// A version of `void::Void` that is GC-able.
#[derive(Clone, Debug, Finalize)]
pub enum GcVoid {}

unsafe impl Trace for GcVoid {
    unsafe_empty_trace!();
}

/// Converts a `Value` to a `Vec<Value>`. Will only convert cons-lists, not
/// vectors.
pub fn as_list<C: 'static + Context>(val: Gc<Value<C>>) -> Option<Vec<Gc<Value<C>>>> {
    let mut out = Vec::new();
    let mut val: &Value<C> = &*val;
    while let &Value::Cons(ref h, ref t, _) = val {
        out.push(h.clone());
        val = t;
    }
    if let &Value::Nil(_) = val {
        Some(out)
    } else {
        None
    }
}

/// Converts a `Value` to a `Vec<(Value, ValueMeta)>`. Will only convert
/// cons-lists, not vectors.
pub fn as_list_meta<C: 'static + Context>(
    val: Gc<Value<C>>,
) -> Option<Vec<(Gc<Value<C>>, C::ValueMeta)>> {
    let mut out = Vec::new();
    let mut val: &Value<C> = &*val;
    while let &Value::Cons(ref h, ref t, ref m) = val {
        out.push((h.clone(), m.clone()));
        val = t;
    }
    if let &Value::Nil(_) = val {
        Some(out)
    } else {
        None
    }
}

/// Converts the given `Value` to a symbol and rest values.
pub fn as_shl<C: 'static + Context>(val: Gc<Value<C>>) -> Option<(Symbol, Vec<Gc<Value<C>>>)> {
    if let Value::Cons(ref h, ref t, _) = *val {
        if let Value::Symbol(sym, _) = **h {
            as_list(t.clone()).map(|t| (sym, t))
        } else {
            None
        }
    } else {
        None
    }
}

/// Converts a `Value` to a `Vec<Symbol>`. Will only convert cons-lists, not
/// vectors.
pub fn as_sym_list<C: 'static + Context>(val: Gc<Value<C>>) -> Option<Vec<Symbol>> {
    let mut out = Vec::new();
    for val in try_opt!(as_list(val)) {
        if let &Value::Symbol(s, _) = &*val {
            out.push(s);
        } else {
            return None;
        }
    }
    Some(out)
}

/// Converts a list of symbol-value pairs to a hashmap.
pub fn from_assoc<C: 'static + Context>(
    val: Gc<Value<C>>,
) -> Option<HashMap<Symbol, Gc<Value<C>>>> {
    let list = try_opt!(as_list(val));
    let mut map = HashMap::new();
    for val in list {
        match *val {
            Value::Cons(ref h, ref t, _) => {
                match **h {
                    Value::Symbol(s, _) => map.insert(s, t.clone()),
                    _ => return None,
                }
            }
            _ => return None,
        };
    }
    Some(map)
}

/// Converts a `Vec<(Value, ValueMeta)>` to a cons-list.
pub fn from_list_meta<C: 'static + Context>(
    mut vec: Vec<(Gc<Value<C>>, C::ValueMeta)>,
) -> Gc<Value<C>> {
    let mut out = Gc::new(Value::Nil(C::ValueMeta::default()));
    while let Some((val, meta)) = vec.pop() {
        out = Gc::new(Value::Cons(val, out, meta));
    }
    out
}

/// Returns whether the given import path is for a module that is "internal,"
/// that is, a module that will not automatically import `std/prelude`.
pub fn is_internal(import_path: Symbol) -> bool {
    let s = import_path.as_str();
    s == "std/prelude" || s.starts_with("std/internal/prelude/")
}

/// Returns whether the given `Value` is a cons-list whose head is the given
/// symbol.
pub fn is_shl<C: 'static + Context>(sym: Symbol, val: Gc<Value<C>>) -> bool {
    if let Value::Cons(ref h, _, _) = *val {
        if let Value::Symbol(s, _) = **h {
            s == sym
        } else {
            false
        }
    } else {
        false
    }
}

/// Converts a `HashMap<Symbol, Value>` (or a compatible `IntoIterator`) to an
/// assoc.
pub fn to_assoc<'a, C, I>(map: I) -> Gc<Value<C>>
where
    C: 'static + Context,
    I: IntoIterator<Item = (&'a Symbol, &'a Gc<Value<C>>)>,
{
    let mut list = vec![];
    for (&k, v) in map {
        let k = Gc::new(Value::Symbol(k, Default::default()));
        let v = v.clone();
        list.push(Gc::new(Value::Cons(k, v, Default::default())));
    }
    Value::list(list, Default::default())
}