marser 0.1.1

Parser combinator toolkit with matcher-level backtracking and rich error reporting.
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

use std::fmt::Display;

use crate::{
    context::ParserContext,
    error::{MatcherRunError, error_handler::ErrorHandler},
    input::{Input, InputStream},
    matcher::{DirectMatchRunner, Matcher, NoMemoizeBacktrackingRunner, runner::MatchRunner},
    parser::{ParserCombinator, internal::ParserImpl},
};

/// Parser produced by [`MatcherCombinator::to`](super::MatcherCombinator::to).
///
/// It runs a matcher and returns a fixed output value when the matcher succeeds.
/// The matcher is evaluated with an empty capture result, so this is intended for
/// ordinary matchers, not `bind!`/`bind_span!`/`bind_slice!` capture binders.
#[derive(Clone)]
pub struct ToParser<Match, Output> {
    matcher: Match,
    output: Output,
}

impl<Match, Output> ToParser<Match, Output> {
    /// Wrap `matcher` and return `output` whenever it succeeds.
    pub fn new(matcher: Match, output: Output) -> Self {
        Self { matcher, output }
    }
}

impl<Match, Output> std::fmt::Debug for ToParser<Match, Output>
where
    Match: std::fmt::Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ToParser")
            .field("matcher", &self.matcher)
            .finish()
    }
}

impl<Match, Output> ParserCombinator for ToParser<Match, Output> {}

impl<'src, Inp, Match, Output> ParserImpl<'src, Inp> for ToParser<Match, Output>
where
    Inp: Input<'src>,
    Match: Matcher<'src, Inp, ((), (), ())>,
    Output: Clone,
{
    type Output = Output;
    const CAN_FAIL: bool = Match::CAN_FAIL;

    #[inline]
    fn parse(
        &self,
        context: &mut ParserContext<'src>,
        error_handler: &mut impl ErrorHandler,
        input: &mut InputStream<'src, Inp>,
    ) -> Result<Option<Self::Output>, MatcherRunError> {
        if Match::CAN_MATCH_DIRECTLY && !error_handler.is_real() && !context.is_in_error_recovery {
            let mut runner = DirectMatchRunner::new(context);
            if runner.run_match(&self.matcher, error_handler, input)? {
                Ok(Some(self.output.clone()))
            } else {
                Ok(None)
            }
        } else {
            let mut runner = NoMemoizeBacktrackingRunner::new(context);
            if runner.run_match(&self.matcher, error_handler, input)? {
                Ok(Some(self.output.clone()))
            } else {
                Ok(None)
            }
        }
    }

    #[inline]
    fn maybe_label(&self) -> Option<Box<dyn Display>> {
        self.matcher.maybe_label()
    }
}