p-arse 0.0.1

the inelegant parser
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

#![feature(box_syntax)]
use p_arse::{any, fun, function::Rec, rec, CharExt, Fun, Parser, TupleExt};

#[test]
fn test_any() {
    let anything = any();
    assert!(anything.p_arse("abc").is_ok());
}

#[test]
fn test_literal() {
    let just_a = 'a'; // "a"
    assert!(just_a.p_arse("a").is_ok());
    assert!(just_a.p_arse("b").is_err());

    let abc = "abc"; // "abc"
    assert!(abc.p_arse("abc").is_ok());
    assert!(abc.p_arse("def").is_err());
}

#[test]
fn test_sequence() {
    let a = ("a",); // "a"
    assert!(a.p_arse("a").is_ok());
    assert!(a.p_arse("x").is_err());

    let ab = ("a", "b"); // "a" "b"
    assert!(ab.p_arse("ab").is_ok());
    assert!(ab.p_arse("xx").is_err());

    let abc = ("a", "b", "c"); // "a" "b" "c"
    assert!(abc.p_arse("abc").is_ok());
    assert!(abc.p_arse("xxx").is_err());
}

#[test]
fn test_sequence_remove() {
    let collect_string = |text: Vec<char>| text.iter().collect::<String>();

    let ws = ' '.zore().ignore();
    let text = 'a'.to('z').more();
    let paragraph = (ws, text, ws).r2().r0().map(collect_string);

    let (text, _tail) = paragraph.p_arse("    text    ").unwrap();
    assert_eq!(text, "text");
}

#[test]
fn test_maps_after_rem() {
    // Doesn't work yet.

    let ws = ' '.zore().ignore();
    let text = 'a'.to('z').more();
    let paragraph = (ws, text, ws).r2().r0().maps(|s| s.to_string());

    let (text, _tail) = paragraph.p_arse("    text    ").unwrap();
    assert_eq!(text, "text");
}

#[test]
fn test_prioritized_choice() {
    let a_or_b_or_c = "a".or("b").or("c"); // "a" / "b" / "c"
    assert!(a_or_b_or_c.p_arse("axxx").is_ok());
    assert!(a_or_b_or_c.p_arse("bxxx").is_ok());
    assert!(a_or_b_or_c.p_arse("cxxx").is_ok());
}

#[test]
fn test_mapping() {
    let parse_digit = |d: char| d.to_digit(10).unwrap();
    let digit = any().map(parse_digit);
    assert_eq!(digit.p_arse("1").unwrap().0, 1);
}

#[test]
fn test_repetition() {
    let bees = "b".zore(); // "b"*
    assert!(bees.p_arse("").is_ok());
    assert!(bees.p_arse("b").is_ok());
    assert!(bees.p_arse("bb").is_ok());
    assert!(bees.p_arse("bbb").is_ok());

    let scream = "a".more(); // "a"+
    assert!(scream.p_arse("").is_err());
    assert!(scream.p_arse("a").is_ok());
    assert!(scream.p_arse("aa").is_ok());
    assert!(scream.p_arse("aaa").is_ok());
}

#[test]
fn test_lookahead() {
    let a_ahead = "a".ahead(); // &"a"
    assert!(a_ahead.p_arse("aaa").is_ok());
    assert!(a_ahead.p_arse("bbb").is_err());

    let a_not_ahead = "a".not_ahead(); // !"a"
    assert!(a_not_ahead.p_arse("bbb").is_ok());
    assert!(a_not_ahead.p_arse("aaa").is_err());
}

#[test]
fn test_named() {
    let x = ",,,".named("x");
    let y = (x,).named("y");
    let z = (y,).named("z");

    assert_eq!(z.p_arse("...").unwrap_err().stack, vec!["x", "y", "z"]);
}

#[test]
fn test_function() {
    // Recursive terminals.

    // A = "a" A?
    let a_string =
        rec(&|tail, a_string| ("a", a_string.opt()).ignore().p_arse(tail));

    assert!(a_string.p_arse("").is_err());
    assert!(a_string.p_arse("a").is_ok());
    assert!(a_string.p_arse("aa").is_ok());
    assert!(a_string.p_arse("aaa").is_ok());

    // Non-recursive terminals.

    // A = "a" "b" "c"
    let abc = fun(&|tail: &str| ("a", "b", "c").ignore().p_arse(tail));

    assert!(abc.p_arse("abc").is_ok());
    assert!(abc.p_arse("xxx").is_err());

    // Capturing the environment.

    let a = "a";
    let b = "b";
    let c = "c";
    let abc: &dyn Fun<_> = &|tail| (a, b, c).ignore().p_arse(tail);
    let abc = fun(abc);

    assert!(abc.p_arse("abc").is_ok());

    let just_a = "a";
    let a_string: &dyn Rec<_> =
        &|tail, a_string| (just_a, a_string.opt()).ignore().p_arse(tail);
    let a_string = rec(&a_string);

    assert!(a_string.p_arse("a").is_ok());
}