parze-declare 0.2.0

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
48
49
50
51
52

#![feature(proc_macro_def_site, proc_macro_quote, proc_macro_hygiene, trait_alias)]

mod rule;
mod expr;

extern crate proc_macro;

use proc_macro::{TokenStream, TokenTree};

#[derive(Debug)]
enum Error {
    UnexpectedToken,
    ExpectedAtom,
    ExpectedPunct,
}

trait TokenStreamExt {
    fn and(self, other: TokenStream) -> TokenStream;
}

impl TokenStreamExt for TokenStream {
    fn and(mut self, other: TokenStream) -> TokenStream {
        self.extend(Some(other));
        self
    }
}

impl TokenStreamExt for TokenTree {
    fn and(self, other: TokenStream) -> TokenStream {
        let mut this = TokenStream::from(self);
        this.extend(Some(other));
        this
    }
}

trait TokenIter = Iterator<Item=TokenTree> + Clone;

fn attempt<'a, 'c: 'a, I, R, E, F>(iter: &mut I, f: F) -> Result<R, E>
    where
        I: TokenIter,
        F: FnOnce(&mut I) -> Result<R, E>,
{
    let mut iter2 = iter.clone();
    let tok = f(&mut iter2)?;
    *iter = iter2;
    Ok(tok)
}

#[proc_macro]
pub fn rule(stream: TokenStream) -> TokenStream {
    rule::parse_rule(&mut stream.into_iter()).unwrap().into()
}