combi 1.0.2

A combinators library with an included rust token parsing implementation
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

//! Matching tokens using a function.
//!
//! TODO: matching macros to make use of `matches!()``
use crate::{Combi, CombiResult};
use proc_macro2::TokenTree;
use proc_macro_error2::{Diagnostic, Level};

use super::{TokenDiagnostic, TokenIter};

#[derive(Clone)]
pub struct Matcher<const PEEK: bool, F>
where
    F: Fn(&TokenTree) -> bool,
{
    match_fn: F,
    repr_str: &'static str,
}

pub fn matcher<const PEEK: bool, F>(match_fn: F, repr_str: &'static str) -> Matcher<PEEK, F>
where
    F: Fn(&TokenTree) -> bool,
{
    Matcher { match_fn, repr_str }
}

impl<const PEEK: bool, F> Combi for Matcher<PEEK, F>
where
    F: Fn(&TokenTree) -> bool,
{
    type Suc = bool;
    type Err = TokenDiagnostic;
    type Con = TokenDiagnostic;
    type Inp = TokenIter;
    type Out = TokenIter;

    #[inline]
    fn comp(
        &self,
        mut input: Self::Inp,
    ) -> (Self::Out, CombiResult<Self::Suc, Self::Con, Self::Err>) {
        // TODO: reduce repetition here
        if PEEK {
            if let Some(tk) = input.peek_next() {
                let res = CombiResult::Suc((self.match_fn)(tk));
                (input, res)
            } else {
                let span = *input.cur_span();
                (
                    input,
                    CombiResult::Err(TokenDiagnostic::from(Diagnostic::spanned(
                        span,
                        Level::Error,
                        "Unexpected end of input".to_owned(),
                    ))),
                )
            }
        } else if let Some(tk) = input.next() {
            let res = CombiResult::Suc((self.match_fn)(&tk));
            (input, res)
        } else {
            let span = *input.cur_span();
            (
                input,
                CombiResult::Err(TokenDiagnostic::from(Diagnostic::spanned(
                    span,
                    Level::Error,
                    "Unexpected end of input".to_owned(),
                ))),
            )
        }
    }

    fn repr(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(f, "{}", self.repr_str)
    }
}