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
|
export fold;
export fold_crate, fold_mod, fold_fn, fold_modlist, fold_fnlist;
export default_seq_fold;
export default_seq_fold_crate;
export default_seq_fold_mod;
export default_seq_fold_fn;
export default_seq_fold_fnlist;
enum fold<T> = t<T>;
type fold_crate<T> = fn~(fold: fold<T>, doc: doc::cratedoc) -> doc::cratedoc;
type fold_mod<T> = fn~(fold: fold<T>, doc: doc::moddoc) -> doc::moddoc;
type fold_fn<T> = fn~(fold: fold<T>, doc: doc::fndoc) -> doc::fndoc;
type fold_modlist<T> = fn~(fold: fold<T>,list: doc::modlist) -> doc::modlist;
type fold_fnlist<T> = fn~(fold: fold<T>,list: doc::fnlist) -> doc::fnlist;
type t<T> = {
ctxt: T,
fold_crate: fold_crate<T>,
fold_mod: fold_mod<T>,
fold_fn: fold_fn<T>,
fold_modlist: fold_modlist<T>,
fold_fnlist: fold_fnlist<T>
};
// This exists because fn types don't infer correctly as record
// initializers, but they do as function arguments
fn mk_fold<T:copy>(
ctxt: T,
fold_crate: fold_crate<T>,
fold_mod: fold_mod<T>,
fold_fn: fold_fn<T>,
fold_modlist: fold_modlist<T>,
fold_fnlist: fold_fnlist<T>
) -> fold<T> {
fold({
ctxt: ctxt,
fold_crate: fold_crate,
fold_mod: fold_mod,
fold_fn: fold_fn,
fold_modlist: fold_modlist,
fold_fnlist: fold_fnlist
})
}
fn default_seq_fold<T:copy>(ctxt: T) -> fold<T> {
mk_fold(
ctxt,
{|f, d| default_seq_fold_crate(f, d)},
{|f, d| default_seq_fold_mod(f, d)},
{|f, d| default_seq_fold_fn(f, d)},
{|f, d| default_seq_fold_modlist(f, d)},
{|f, d| default_seq_fold_fnlist(f, d)}
)
}
fn default_seq_fold_crate<T>(
fold: fold<T>,
doc: doc::cratedoc
) -> doc::cratedoc {
~{
topmod: fold.fold_mod(fold, doc.topmod)
}
}
fn default_seq_fold_mod<T>(
fold: fold<T>,
doc: doc::moddoc
) -> doc::moddoc {
~{
mods: fold.fold_modlist(fold, doc.mods),
fns: fold.fold_fnlist(fold, doc.fns)
with *doc
}
}
fn default_seq_fold_fn<T>(
_fold: fold<T>,
doc: doc::fndoc
) -> doc::fndoc {
doc
}
fn default_seq_fold_modlist<T>(
fold: fold<T>,
list: doc::modlist
) -> doc::modlist {
doc::modlist(vec::map(*list) {|doc|
fold.fold_mod(fold, doc)
})
}
fn default_seq_fold_fnlist<T>(
fold: fold<T>,
list: doc::fnlist
) -> doc::fnlist {
doc::fnlist(vec::map(*list) {|doc|
fold.fold_fn(fold, doc)
})
}
#[cfg(test)]
mod tests {
#[test]
fn default_fold_should_produce_same_doc() {
let source = "mod a { fn b() { } mod c { fn d() { } } }";
let ast = parse::from_str(source);
let doc = extract::extract(ast, "");
let fld = default_seq_fold(());
let folded = fld.fold_crate(fld, doc);
assert doc == folded;
}
}
|
