pest 1.0.2

The Elegant Parser
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

extern crate pest;

use std::io::{self, Write};

use pest::{state, Error, Parser, ParserState};
use pest::Position;
use pest::iterators::Pairs;

#[allow(dead_code, non_camel_case_types)]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
enum Rule {
    expr,
    paren,
    paren_end
}

struct ParenParser;

impl Parser<Rule> for ParenParser {
    fn parse(rule: Rule, input: &str) -> Result<Pairs<Rule>, Error<Rule>> {
        fn expr<'i>(
            pos: Position<'i>,
            state: &mut ParserState<'i, Rule>
        ) -> Result<Position<'i>, Position<'i>> {
            state.sequence(move |state| {
                pos.sequence(|p| p.repeat(|p| paren(p, state)).and_then(|p| p.at_end()))
            })
        }

        fn paren<'i>(
            pos: Position<'i>,
            state: &mut ParserState<'i, Rule>
        ) -> Result<Position<'i>, Position<'i>> {
            state.rule(Rule::paren, pos, |state, pos| {
                state.sequence(move |state| {
                    pos.sequence(|p| {
                        p.match_string("(")
                            .and_then(|p| {
                                p.optional(|p| {
                                    state.sequence(move |state| {
                                        p.sequence(|p| {
                                            state
                                                .lookahead(true, move |_| {
                                                    p.lookahead(true, |p| p.match_string("("))
                                                })
                                                .and_then(|p| p.repeat(|p| paren(p, state)))
                                        })
                                    })
                                })
                            })
                            .and_then(|p| {
                                state.rule(Rule::paren_end, p, |_, pos| pos.match_string(")"))
                            })
                    })
                })
            })
        }

        state(input, move |mut state, pos| match rule {
            Rule::expr => expr(pos, &mut state),
            Rule::paren => paren(pos, &mut state),
            _ => unreachable!()
        })
    }
}

#[derive(Debug)]
struct Paren(Vec<Paren>);

fn expr(pairs: Pairs<Rule>) -> Vec<Paren> {
    pairs
        .filter(|p| p.as_rule() == Rule::paren)
        .map(|p| Paren(expr(p.into_inner())))
        .collect()
}

fn main() {
    loop {
        let mut line = String::new();

        print!("> ");
        io::stdout().flush().unwrap();

        io::stdin().read_line(&mut line).unwrap();
        line.pop();

        match ParenParser::parse(Rule::expr, &line) {
            Ok(pairs) => println!("{:?}", expr(pairs)),
            Err(e) => println!("\n{}", e)
        };
    }
}