marser 0.1.2

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

use std::fmt::Display;

use crate::{
    context::ParserContext,
    error::{MatcherRunError, error_handler::ErrorHandler},
    input::{Input, InputStream},
    parser::{Parser, ParserCombinator},
};

/// Parser wrapper returned by [`crate::parser::ParserCombinator::map_output`].
#[derive(Clone)]
pub struct OutputMapper<Parser, MapFn> {
    parser: Parser,
    map_fn: MapFn,
}

impl<Parser, MapFn> std::fmt::Debug for OutputMapper<Parser, MapFn>
where
    Parser: std::fmt::Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("OutputMapper")
            .field("parser", &self.parser)
            .finish()
    }
}

impl<Parser, MapFn> OutputMapper<Parser, MapFn> {
    /// Wrap `parser` and map each successful output with `map_fn`.
    pub fn new(parser: Parser, map_fn: MapFn) -> Self {
        Self { parser, map_fn }
    }
}

impl<Parser, MapFn> ParserCombinator for OutputMapper<Parser, MapFn> where Parser: ParserCombinator {}

impl<'src, Inp: Input<'src>, NodeIn, NodeOut, Pars, MapFn> super::internal::ParserImpl<'src, Inp>
    for OutputMapper<Pars, MapFn>
where
    Pars: Parser<'src, Inp, Output = NodeIn> + Clone,
    Inp: Input<'src>,
    MapFn: Fn(NodeIn) -> NodeOut + Clone,
{
    type Output = NodeOut;
    const CAN_FAIL: bool = Pars::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 let Some(result) = self.parser.parse(context, error_handler, input)? {
            Ok(Some((self.map_fn)(result)))
        } else {
            Ok(None)
        }
    }

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