typeset 3.1.2

A DSL for defining source code pretty printers
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Pass 3: Serial → LinearDoc (lift newlines to spine)

use crate::compiler::types::{
    Attr, LinearComp, LinearDoc, LinearObj, LinearTerm, Serial, SerialComp, SerialTerm,
};
use crate::util::compose;
use bumpalo::Bump;

pub fn linearize<'b, 'a: 'b>(mem: &'b Bump, serial: &'a Serial<'a>) -> &'b LinearDoc<'b> {
    fn _nil<'a>(mem: &'a Bump) -> &'a LinearDoc<'a> {
        mem.alloc(LinearDoc::Nil)
    }

    fn _cons<'a>(
        mem: &'a Bump,
        obj: &'a LinearObj<'a>,
        doc: &'a LinearDoc<'a>,
    ) -> &'a LinearDoc<'a> {
        mem.alloc(LinearDoc::Cons(obj, doc))
    }

    fn _next<'a>(
        mem: &'a Bump,
        comp: &'a LinearTerm<'a>,
        term: &'a LinearComp<'a>,
        obj: &'a LinearObj<'a>,
    ) -> &'a LinearObj<'a> {
        mem.alloc(LinearObj::Next(comp, term, obj))
    }

    fn _last<'a>(mem: &'a Bump, term: &'a LinearTerm<'a>) -> &'a LinearObj<'a> {
        mem.alloc(LinearObj::Last(term))
    }

    fn _null<'a>(mem: &'a Bump) -> &'a LinearTerm<'a> {
        mem.alloc(LinearTerm::Null)
    }

    fn _text<'a>(mem: &'a Bump, data: &'a str) -> &'a LinearTerm<'a> {
        mem.alloc(LinearTerm::Text(data))
    }

    fn _nest<'a>(mem: &'a Bump, term: &'a LinearTerm<'a>) -> &'a LinearTerm<'a> {
        mem.alloc(LinearTerm::Nest(term))
    }

    fn _pack<'a>(mem: &'a Bump, index: u64, term: &'a LinearTerm<'a>) -> &'a LinearTerm<'a> {
        mem.alloc(LinearTerm::Pack(index, term))
    }

    fn _comp<'a>(mem: &'a Bump, attr: Attr) -> &'a LinearComp<'a> {
        mem.alloc(LinearComp::Comp(attr))
    }

    fn _grp<'a>(mem: &'a Bump, index: u64, comp: &'a LinearComp<'a>) -> &'a LinearComp<'a> {
        mem.alloc(LinearComp::Grp(index, comp))
    }

    fn _seq<'a>(mem: &'a Bump, index: u64, comp: &'a LinearComp<'a>) -> &'a LinearComp<'a> {
        mem.alloc(LinearComp::Seq(index, comp))
    }

    fn _visit_serial<'b, 'a: 'b, R>(
        mem: &'b Bump,
        serial: &'a Serial<'a>,
        line: &'b dyn Fn(&'b Bump, &'b LinearObj<'b>) -> &'b LinearObj<'b>,
        cont: &'b dyn Fn(&'b Bump, &'b LinearDoc<'b>) -> R,
    ) -> R {
        match serial {
            Serial::Next(term, SerialComp::Line, serial1) => _visit_term(
                mem,
                term,
                mem.alloc(move |mem, term1| {
                    _visit_serial(
                        mem,
                        serial1,
                        mem.alloc(|_mem, obj| obj),
                        mem.alloc(move |mem, serial2| {
                            cont(mem, _cons(mem, line(mem, _last(mem, term1)), serial2))
                        }),
                    )
                }),
            ),
            Serial::Next(term, comp, serial1) => _visit_term(
                mem,
                term,
                mem.alloc(move |mem, term1| {
                    _visit_comp(
                        mem,
                        comp,
                        mem.alloc(move |mem, comp1| {
                            _visit_serial(
                                mem,
                                serial1,
                                compose(
                                    mem,
                                    line,
                                    mem.alloc(move |mem, obj| _next(mem, term1, comp1, obj)),
                                ),
                                cont,
                            )
                        }),
                    )
                }),
            ),
            Serial::Last(term, Serial::Past) => _visit_term(
                mem,
                term,
                mem.alloc(|mem, term1| {
                    cont(mem, _cons(mem, line(mem, _last(mem, term1)), _nil(mem)))
                }),
            ),
            _ => unreachable!("Invariant"),
        }
    }

    fn _visit_term<'b, 'a: 'b, R>(
        mem: &'b Bump,
        term: &'a SerialTerm<'a>,
        cont: &'b dyn Fn(&'b Bump, &'b LinearTerm<'b>) -> R,
    ) -> R {
        match term {
            SerialTerm::Null => cont(mem, _null(mem)),
            SerialTerm::Text(data) => cont(mem, _text(mem, data)),
            SerialTerm::Nest(term1) => _visit_term(
                mem,
                term1,
                compose(mem, cont, mem.alloc(|mem, term2| _nest(mem, term2))),
            ),
            SerialTerm::Pack(index, term1) => _visit_term(
                mem,
                term1,
                compose(mem, cont, mem.alloc(|mem, term2| _pack(mem, *index, term2))),
            ),
        }
    }

    fn _visit_comp<'b, 'a: 'b, R>(
        mem: &'b Bump,
        comp: &'a SerialComp<'a>,
        cont: &'b dyn Fn(&'b Bump, &'b LinearComp<'b>) -> R,
    ) -> R {
        match comp {
            SerialComp::Line => unreachable!("Invariant"),
            SerialComp::Comp(attr) => cont(mem, _comp(mem, *attr)),
            SerialComp::Grp(index, comp1) => _visit_comp(
                mem,
                comp1,
                compose(mem, cont, mem.alloc(|mem, comp1| _grp(mem, *index, comp1))),
            ),
            SerialComp::Seq(index, comp1) => _visit_comp(
                mem,
                comp1,
                compose(mem, cont, mem.alloc(|mem, comp1| _seq(mem, *index, comp1))),
            ),
        }
    }

    _visit_serial(
        mem,
        serial,
        mem.alloc(|_mem, obj| obj),
        mem.alloc(|_mem, doc| doc),
    )
}