knave-expand 0.14.22

The reading, scoping and expansion stages of knave
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

use crate::reader::{Form, FormKind};

pub struct HeldBytes;

impl HeldBytes {
    pub const PER_FORM: usize = 64;

    pub fn of_form(form: &Form) -> usize {
        let mut held = 0;
        let mut waiting = vec![form];
        while let Some(form) = waiting.pop() {
            held += Self::PER_FORM + Self::text_bytes(form.kind());
            waiting.extend(form.as_list().unwrap_or_default());
        }
        held
    }

    fn text_bytes(kind: &FormKind) -> usize {
        match kind {
            FormKind::String(text) => text.len(),
            FormKind::Symbol(symbol) => symbol.name().len(),
            FormKind::Number(number) => number.text().len(),
            FormKind::List(_) => 0,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::HeldBytes;
    use crate::reader::{Form, FormKind, Symbol};
    use crate::source::{SourceId, Span};

    struct HeldForms;

    impl HeldForms {
        fn span() -> Span {
            Span::new(SourceId::new(0), 0..1)
        }

        fn text(bytes: usize) -> Form {
            Form::new(FormKind::String("x".repeat(bytes).into()), Self::span())
        }
    }

    #[test]
    fn text_holds_its_bytes_beside_its_form() {
        assert_eq!(HeldBytes::of_form(&HeldForms::text(100)), 64 + 100);
    }

    #[test]
    fn a_list_holds_itself_and_each_form_of_its_tree() {
        let symbol = Form::new(FormKind::Symbol(Symbol::new("ab")), HeldForms::span());
        let list = Form::new(
            FormKind::List(vec![symbol, HeldForms::text(3)]),
            HeldForms::span(),
        );
        assert_eq!(HeldBytes::of_form(&list), 64 + (64 + 2) + (64 + 3));
    }
}