Trait Parser

pub trait Parser<In: Input, Out, Reason = Infallible>: Sized + FnMut(In) -> ParsingResult<In, Out, Reason> {
    // Provided methods
    fn parse(&mut self, input: In) -> ParsingResult<In, Out, Reason> { ... }
    fn filter(self, f: impl FnMut(&Out) -> bool) -> impl Parser<In, Out, Reason> { ... }
    fn filter_fatal(
        self,
        reason: Reason,
        f: impl FnMut(&Out) -> bool,
    ) -> impl Parser<In, Out, Reason>
       where Reason: Clone { ... }
    fn map_reason<NewReason>(
        self,
        f: impl FnMut(Reason) -> NewReason,
    ) -> impl Parser<In, Out, NewReason> { ... }
    fn adapt_reason<NewReason>(self) -> impl Parser<In, Out, NewReason>
       where Infallible: From<Reason> { ... }
    fn map<NewOut>(
        self,
        parser: impl MappingParser<In, Out, NewOut, Reason>,
    ) -> impl Parser<In, NewOut, Reason> { ... }
    fn map_out<NewOut>(
        self,
        f: impl FnMut(Out) -> NewOut,
    ) -> impl Parser<In, NewOut, Reason> { ... }
    fn map_until<NewOut>(
        self,
        f: impl FnMut(Out) -> Option<NewOut>,
    ) -> impl Parser<In, NewOut, Reason> { ... }
    fn call<F>(self, f: F) -> impl Parser<In, F::Output, Reason>
       where F: FnMut<Out>,
             Out: Tuple { ... }
    fn or(
        self,
        parser: impl Parser<In, Out, Reason>,
    ) -> impl Parser<In, Out, Reason> { ... }
    fn or_nonempty(
        self,
        parser: impl Parser<In, Out, Reason>,
    ) -> impl Parser<In, Out, Reason> { ... }
    fn or_map_rest(
        self,
        f: impl FnMut(In) -> Out,
    ) -> impl Parser<In, Out, Reason> { ... }
    fn or_value(self, value: Out) -> impl Parser<In, Out, Reason>
       where Out: Clone { ... }
    fn and<Other>(
        self,
        parser: impl Parser<In, Other, Reason>,
    ) -> impl Parser<In, (Out, Other), Reason> { ... }
    fn and_value<Other: Clone>(
        self,
        value: Other,
    ) -> impl Parser<In, (Out, Other), Reason> { ... }
    fn add<New>(
        self,
        parser: impl Parser<In, New, Reason>,
    ) -> impl Parser<In, Out::Appended<New>, Reason>
       where Out: Tuple { ... }
    fn add_value<Other: Clone>(
        self,
        value: Other,
    ) -> impl Parser<In, Out::Appended<Other>, Reason>
       where Out: Tuple { ... }
    fn then<NewOut>(
        self,
        parser: impl Parser<In, NewOut, Reason>,
    ) -> impl Parser<In, NewOut, Reason> { ... }
    fn skip<Skipped>(
        self,
        parser: impl Parser<In, Skipped, Reason>,
    ) -> impl Parser<In, Out, Reason> { ... }
    fn expect<NewReason: Clone>(
        self,
        expected: NewReason,
    ) -> impl Parser<In, Out, NewReason> { ... }
    fn or_reason(self, reason: Reason) -> impl Parser<In, Out, Reason>
       where Reason: Clone { ... }
    fn or_reason_if_nonempty(
        self,
        reason: Reason,
    ) -> impl Parser<In, Out, Reason>
       where Reason: Clone { ... }
    fn get_span(self) -> impl Parser<In, (Out, In), Reason> { ... }
    fn add_span(self) -> impl Parser<In, Out::Appended<In>, Reason>
       where Out: Tuple { ... }
    fn get_rest(self) -> impl Parser<In, (Out, In), Reason> { ... }
    fn add_rest(self) -> impl Parser<In, Out::Appended<In>, Reason>
       where Out: Tuple { ... }
    fn maybe(self) -> impl Parser<In, Option<Out>, Reason> { ... }
    fn ok(self) -> impl Parser<In, bool, Reason> { ... }
    fn repeat(self) -> impl Parser<In, (), Reason> { ... }
    fn collect<C: Default + Extend<Out>>(self) -> impl Parser<In, C, Reason> { ... }
    fn dbg(self, label: impl Display) -> impl Parser<In, Out, Reason>
       where In: Input,
             Out: Debug,
             Reason: Debug { ... }
    fn iter(self, input: In) -> Iter<In, Out, Reason, Self>  { ... }
    fn with_full_error<'a>(
        self,
        path: impl PathLike<'a>,
        full_src: &'a str,
    ) -> impl FnOnce(In) -> Result<(In, Out), FullParsingError<'a, Reason>>
       where In: Input { ... }
}

A trait representing a function that takes some string-like input and returns either a tuple of (the rest of the input, the output) or a ParsingError.

Provided Methods

fn parse(&mut self, input: In) -> ParsingResult<In, Out, Reason>

Use the parser to produce the output.

Examples found in repository

examples/xml.rs (line 52)

fn parse_ident<In: Input, Reason>(input: In) -> ParsingResult<In, In, Reason> {
    parse_until(|c| ['>', '/', '='].contains(&c) || c.is_whitespace())
        .filter(|i: &In| !i.is_empty())
        .parse(input)
}

fn parse_string<In: Input>(input: In) -> ParsingResult<In, In, Error> {
    parse('"')
        .then(parse_until_ex(NotEscaped('\\', '"')).or_reason(Error::UnclosedString))
        .parse(input)
}

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn filter(self, f: impl FnMut(&Out) -> bool) -> impl Parser<In, Out, Reason>

Turns output into a recoverable error if the output doesn’t meet a condition.

Examples found in repository

examples/xml.rs (line 51)

fn parse_ident<In: Input, Reason>(input: In) -> ParsingResult<In, In, Reason> {
    parse_until(|c| ['>', '/', '='].contains(&c) || c.is_whitespace())
        .filter(|i: &In| !i.is_empty())
        .parse(input)
}

fn filter_fatal( self, reason: Reason, f: impl FnMut(&Out) -> bool, ) -> impl Parser<In, Out, Reason>

where Reason: Clone,

Like Parser::filter, but the possible error is instead fatal, with reason

fn map_reason<NewReason>( self, f: impl FnMut(Reason) -> NewReason, ) -> impl Parser<In, Out, NewReason>

Changes the error reason by passing it through f.

fn adapt_reason<NewReason>(self) -> impl Parser<In, Out, NewReason>

where Infallible: From<Reason>,

Converts the reason, if present, to another type using the From trait.

fn map<NewOut>( self, parser: impl MappingParser<In, Out, NewOut, Reason>, ) -> impl Parser<In, NewOut, Reason>

Transforms the input & the output of the parser, if present.

The argument is a function that maps the input & the current output of the parser to the rest of the input & the new output.

See match_out

Examples found in repository

examples/xml.rs (lines 83-90)

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn map_out<NewOut>( self, f: impl FnMut(Out) -> NewOut, ) -> impl Parser<In, NewOut, Reason>

Like Parser::map, but only maps the current output, if present.

Examples found in repository

examples/xml.rs (line 71)

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn xml_fragments<In: Input>(
    input: In,
) -> impl Iterator<Item = Result<Fragment<In>, ParsingError<In, Error>>> {
    parse_tag
        .or_nonempty(parse_until('<').map_out(Fragment::Text))
        .iter(input)
}

fn map_until<NewOut>( self, f: impl FnMut(Out) -> Option<NewOut>, ) -> impl Parser<In, NewOut, Reason>

Tranforms the output of the parser, if present, or try parsing the next value.

fn call<F>(self, f: F) -> impl Parser<In, F::Output, Reason>

where F: FnMut<Out>, Out: Tuple,

Available on crate feature nightly only.

Like Parser::map, but calls the provdied function using the Nightly FnMut::call_mut method, effectively spreading the output as the arguments of the function.

The following nIghtly Rust code:

use shrimple_parser::Parser;
parser.call(u32::pow)

is equivalent to the following stable Rust code:

use shrimple_parser::Parser;
parser.map(|(x, y)| u32::pow(x, y))

T for this method is constrained not by the crate::Tuple trait, but by the unstable standard trait core::marker::Tuple, which means that T can be a tuple of absolutely any length.

See also: crate::call, a macro for a stable alternative to this method.

fn or( self, parser: impl Parser<In, Out, Reason>, ) -> impl Parser<In, Out, Reason>

Replaces a recoverable error with the result of parser.

The input fed into the second parser is the rest of the input returned by the first parser.

Warning

Do not use this in combination with Parser::iter; Use Parser::or_nonempty

fn or_nonempty( self, parser: impl Parser<In, Out, Reason>, ) -> impl Parser<In, Out, Reason>

Like Parser::or, but keeps the error if the rest of the input is empty.

This allows to avoid slipping into an infinite loop, e.g. when using Parser::iter somewhere down the line.

Examples found in repository

examples/xml.rs (line 100)

fn xml_fragments<In: Input>(
    input: In,
) -> impl Iterator<Item = Result<Fragment<In>, ParsingError<In, Error>>> {
    parse_tag
        .or_nonempty(parse_until('<').map_out(Fragment::Text))
        .iter(input)
}

fn or_map_rest(self, f: impl FnMut(In) -> Out) -> impl Parser<In, Out, Reason>

Replaces a recoverable error with the transformed remains of the input. If the rest of the input in the recoverable error is already empty, does nothing. The returned remains of the input are an empty string.

fn or_value(self, value: Out) -> impl Parser<In, Out, Reason>

where Out: Clone,

Replaces a recoverable error with value & the rest of the input in the recoverable error.

Be aware that value will be cloned every time it’s to be returned.

See Parser::or, Parser::or_nonempty, Parser::or_map_rest.

fn and<Other>( self, parser: impl Parser<In, Other, Reason>, ) -> impl Parser<In, (Out, Other), Reason>

Parses the rest of the input after the first parser, returning both outputs & short-circuiting on an error.

The reason for the errors of the first parser is adapted to the one of the second parser.

See also Parser::add, Parser::and_value.

Examples found in repository

examples/xml.rs (lines 64-70)

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn and_value<Other: Clone>( self, value: Other, ) -> impl Parser<In, (Out, Other), Reason>

Adds a value to the output of the parser

Be aware that value will be cloned every time it’s to be returned.

See Parser::and.

fn add<New>( self, parser: impl Parser<In, New, Reason>, ) -> impl Parser<In, Out::Appended<New>, Reason>

where Out: Tuple,

Like Parser::and, but specific to parsers that output a tuple: the new output is appended to the tuple of other tuples using the Tuple trait.

fn add_value<Other: Clone>( self, value: Other, ) -> impl Parser<In, Out::Appended<Other>, Reason>

where Out: Tuple,

Like Parser::and_value, but specific to parsers that output a tuple: the new output is appended to the tuple of other tuples using the Tuple trait.

fn then<NewOut>( self, parser: impl Parser<In, NewOut, Reason>, ) -> impl Parser<In, NewOut, Reason>

Like Parser::and, but discards the output of the first parser. The reason for the errors of the first parser is adapted to the one of the second parser.

Examples found in repository

examples/xml.rs (line 57)

fn parse_string<In: Input>(input: In) -> ParsingResult<In, In, Error> {
    parse('"')
        .then(parse_until_ex(NotEscaped('\\', '"')).or_reason(Error::UnclosedString))
        .parse(input)
}

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn skip<Skipped>( self, parser: impl Parser<In, Skipped, Reason>, ) -> impl Parser<In, Out, Reason>

Same as Parser::and but discards the output and the recoverable error of the second parser.

Effectively, all this function does is advance the input to right after the second parser, if it succeeds, otherwise the input stays as if only the first parser was called.

Examples found in repository

examples/xml.rs (line 63)

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn expect<NewReason: Clone>( self, expected: NewReason, ) -> impl Parser<In, Out, NewReason>

Sets the reason for errors returned from the parser, making all errors fatal.

fn or_reason(self, reason: Reason) -> impl Parser<In, Out, Reason>

where Reason: Clone,

Makes a recoverable error fatal by giving it a reason. If the error is already fatal, nothing is changed.

Examples found in repository

examples/xml.rs (line 57)

fn parse_string<In: Input>(input: In) -> ParsingResult<In, In, Error> {
    parse('"')
        .then(parse_until_ex(NotEscaped('\\', '"')).or_reason(Error::UnclosedString))
        .parse(input)
}

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn or_reason_if_nonempty(self, reason: Reason) -> impl Parser<In, Out, Reason>

where Reason: Clone,

Like Parser::or_reason but does nothing if the rest of the input is empty.

Be aware that reason is cloned every time it’s to be returned.

fn get_span(self) -> impl Parser<In, (Out, In), Reason>

Adds the part of the input that was consumed by the parser to the outputs.

If the input increased in length after the parser (which should not happen), an empty string is added. See also Parser::add_span, which adds the span to the tuple of other outputs.

fn add_span(self) -> impl Parser<In, Out::Appended<In>, Reason>

where Out: Tuple,

Like Parser::get_span, but adds the output to the tuple of other outputs using the Tuple trait.

fn get_rest(self) -> impl Parser<In, (Out, In), Reason>

Adds a copy of rest of the input to the output.

fn add_rest(self) -> impl Parser<In, Out::Appended<In>, Reason>

where Out: Tuple,

Like Parser::get_rest, but adds the input to the tuple of other outputs using the Tuple trait.

fn maybe(self) -> impl Parser<In, Option<Out>, Reason>

Replaces a recoverable error with None, making the output optional.

Examples found in repository

examples/xml.rs (line 69)

fn parse_attr<In: Input>(input: In) -> ParsingResult<In, Attr<In>, Error> {
    parse_ident
        .skip(parse_whitespace)
        .and(
            parse('=')
                .skip(parse_whitespace)
                .then(parse_string.or_reason(Error::NoAttrValue))
                .skip(parse_whitespace)
                .maybe(),
        )
        .map_out(from_tuple!(Attr { name, value }))
        .parse(input)
}

fn ok(self) -> impl Parser<In, bool, Reason>

Replaces the output with true and a recoverable error with false

Examples found in repository

examples/xml.rs (line 79)

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn repeat(self) -> impl Parser<In, (), Reason>

Repeats the parser until an error is met, discarding all the output.

fn collect<C: Default + Extend<Out>>(self) -> impl Parser<In, C, Reason>

Applies the parser repeatedly, collecting the output into a collection, until an error is met.

Examples found in repository

examples/xml.rs (line 86)

fn parse_tag<In: Input>(input: In) -> ParsingResult<In, Fragment<In>, Error> {
    parse_whitespace::<In, Error>
        .then(parse('<'))
        .then(parse_whitespace)
        .then(parse('/').ok())
        .skip(parse_whitespace)
        .and(parse_ident)
        .skip(parse_whitespace)
        .map(match_out! {
            (true, name) => ready(Fragment::ClosingTag { name }),
            (false, name) => parse_attr
                .collect()
                .and(parse('/').ok())
                .skip(parse_whitespace)
                .map_out(|(attrs, self_closing)| Fragment::Tag { self_closing, name: name.clone(), attrs })
        })
        .skip(parse_whitespace)
        .skip(parse('>').or_reason(Error::TagUnclosed))
        .parse(input)
}

fn dbg(self, label: impl Display) -> impl Parser<In, Out, Reason>

where In: Input, Out: Debug, Reason: Debug,

Prints the output using its Debug implementation & the first 16 bytes of the rest of the input, all along with a custom provided message.

fn iter(self, input: In) -> Iter<In, Out, Reason, Self>

Turns the parser into an iterator that yields output until the first recoverable error. If an error is yielded from the iterator, it’s guaranteed to be fatal.

Examples found in repository

examples/xml.rs (line 101)

fn xml_fragments<In: Input>(
    input: In,
) -> impl Iterator<Item = Result<Fragment<In>, ParsingError<In, Error>>> {
    parse_tag
        .or_nonempty(parse_until('<').map_out(Fragment::Text))
        .iter(input)
}

fn with_full_error<'a>( self, path: impl PathLike<'a>, full_src: &'a str, ) -> impl FnOnce(In) -> Result<(In, Out), FullParsingError<'a, Reason>>

where In: Input,

Augments the parsing error, if present, with location in the input. path is the reported path to the file where the error occured. Note that the input passed here is only used for error reporting, not as the input to the parser.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<In, Out, Reason, F> Parser<In, Out, Reason> for F

where In: Input, F: FnMut(In) -> ParsingResult<In, Out, Reason>,