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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Recovery parsers for converting errors into continuations/successes

use std::marker::PhantomData;

use super::{TokenDiagnostic, TokenIter};
use crate::{Combi, CombiResult, Repr};
use derive_where::derive_where;
use proc_macro_error2::{DiagnosticExt, SpanRange};

/// Recover until the parser succeeds with true
pub fn until<P, T>(parser: P) -> Until<P, T>
where
    P: Combi<
        Inp = TokenIter,
        Out = TokenIter,
        Suc = bool,
        Con = TokenDiagnostic,
        Err = TokenDiagnostic,
    >,
{
    Until {
        parser,
        _marker: PhantomData,
    }
}

#[derive_where(Clone; P)]
pub struct Until<P, T>
where
    P: Combi<
        Inp = TokenIter,
        Out = TokenIter,
        Suc = bool,
        Con = TokenDiagnostic,
        Err = TokenDiagnostic,
    >,
{
    parser: P,
    _marker: PhantomData<T>,
}

impl<P, T> Combi for Until<P, T>
where
    P: Combi<
        Inp = TokenIter,
        Out = TokenIter,
        Suc = bool,
        Con = TokenDiagnostic,
        Err = TokenDiagnostic,
    >,
{
    type Suc = T;
    type Err = TokenDiagnostic;
    type Con = TokenDiagnostic;
    type Inp = (TokenDiagnostic, TokenIter);
    type Out = TokenIter;

    #[inline]
    fn comp(
        &self,
        (mut err, mut input): Self::Inp,
    ) -> (
        Self::Out,
        crate::CombiResult<Self::Suc, Self::Con, Self::Err>,
    ) {
        let start_span = *input.cur_span();

        loop {
            let (p_out, p_res) = self.parser.comp(input);
            input = p_out;
            match p_res {
                crate::CombiResult::Suc(true) => {
                    err.main = err.main.span_range_note(
                        SpanRange {
                            first: start_span,
                            last: *input.cur_span(),
                        },
                        format!("Ignored by recovering to {}", Repr(&self.parser)),
                    );
                    return (input, CombiResult::Con(err));
                }
                crate::CombiResult::Con(_) | crate::CombiResult::Suc(false) => {
                    if input.next().is_none() {
                        return (input, CombiResult::Err(err));
                    }
                }
                // If failing, just propagate the original error
                crate::CombiResult::Err(_) => return (input, CombiResult::Err(err)),
            }
        }
    }

    fn repr(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        Ok(())
    }
}