parze 0.4.1

A clean, efficient parser combinator
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

use parze::prelude::*;

#[derive(Clone, Debug, PartialEq)]
enum Instr {
    Add,
    Sub,
    Left,
    Right,
    In,
    Out,
    Loop(Vec<Instr>),
}

#[test]
#[allow(unused_variables)]
fn simple() {
    parsers! {
        sym: Parser<_, _> = { '+' }

        or: Parser<_, _> = { '+' | '-' }

        then: Parser<_, _> = { '+' & '-' }

        repeat_at_least_once: Parser<_, _> = { ('+' & '-')+ }

        repeater_4: Parser<_, _> = { '+'.repeat(4) }

        mapper: Parser<_, _> = { '+' => { |c| format!("{}", c) } }

        bf: Parser<_, _> = {
            ( '+' -> { Instr::Add }
            | '-' -> { Instr::Sub }
            | '<' -> { Instr::Left }
            | '>' -> { Instr::Right }
            | ',' -> { Instr::In }
            | '.' -> { Instr::Out }
            | '[' -& bf &- ']' => { |i| Instr::Loop(i) }
            )*
        }
    }

    let foo: Parser<_, _> = rule! {
        | '0' & '1' => { |_| ('!', '?') }
        | 'a' & (('b' *= ..) => { |_| '!' })
        | 'a' & ('b' *) -> ('!', '@')
    };
}