eclisp 0.1.1

Bindings for Embeddable Common Lisp
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

use crate::Value;

#[derive(thiserror::Error, Debug, PartialEq, Eq)]
pub enum ListError {
    #[error("Expected a cons cell")]
    NotCons,

    #[error("Improper list")]
    ImproperList,

    #[error("Failed to allocate Lisp root")]
    AllocationFailed,
}

pub struct ListIter<'a, 'rt> {
    start: Option<&'a Value<'rt>>,
    tail: Option<Value<'rt>>,
}

impl<'a, 'rt> ListIter<'a, 'rt> {
    pub(crate) fn new(list: &'a Value<'rt>) -> Self {
        Self {
            start: Some(list),
            tail: None,
        }
    }
}

impl<'a, 'rt> Iterator for ListIter<'a, 'rt> {
    type Item = Result<Value<'rt>, ListError>;

    /// DOES NOT DETECT INFINITE LISTS
    fn next(&mut self) -> Option<Self::Item> {
        let current = match self.tail.as_ref() {
            Some(tail) => tail,
            None => self.start.take()?,
        };

        if current.is_nil() {
            self.tail = None;
            return None;
        }

        if !current.is_cons() {
            self.tail = None;
            return Some(Err(ListError::ImproperList));
        }

        let result = (|| {
            let head = current.car()?;
            let tail = current.cdr()?;
            Ok((head, tail))
        })();

        match result {
            Ok((head, tail)) => {
                self.tail = Some(tail);
                Some(Ok(head))
            }
            Err(error) => {
                self.tail = None;
                Some(Err(error))
            }
        }
    }
}