Struct PBind 

pub struct PBind<P, O1, O2> { /* private fields */ }

A parser combinator that applies a transformation function to the result of a parser.

This is useful for mapping parsed values into a new representation, such as converting a parsed string into an integer, or wrapping a result in a custom enum.

Type Parameters

• P: The inner parser
• O1: The output type of the inner parser P
• O2: The output type after applying the transformation function

Trait Implementations

impl<P: Clone, O1: Clone, O2: Clone> Clone for PBind<P, O1, O2>

fn clone(&self) -> PBind<P, O1, O2>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, P, K, O1, O2> Parser<'a, K, O2> for PBind<P, O1, O2>

where K: PartialEq + Clone + 'a, O1: Clone + 'a, O2: Clone + 'a, P: Parser<'a, K, O1>,

fn then<P2, O2>(self, p2: P2) -> PSeq<Self, P2>

where O2: Clone + 'a, P2: Parser<'a, K, O2>,

Sequence two parsers and return a tuple of their results.

fn or<P2>(self, p2: P2) -> POr<Self, P2>

where P2: Parser<'a, K, O>,

Try this parser or an alternative parser if this one fails.

fn map<O2, F>(self, f: F) -> PBind<Self, O, O2>

where F: Fn(O) -> O2 + 'static, O2: Clone + 'a,

Apply a function to transform the output of the parser.

fn between<A, P1, P2>(self, l: P1, r: P2) -> PBetween<P1, Self, P2, A>

where A: Clone + 'a, P1: Parser<'a, K, A>, P2: Parser<'a, K, A>,

Apply this parser between two delimiters, discarding the delimiters’ results.

fn many(self) -> PMany<Self>

Match this parser zero or more times and collect the results. This is the by default behavior of crate::parser::many::PMany yet one can specialize behavior with crate::parser::many::PMany::at_least and crate::parser::many::PMany::at_most

fn many1(self) -> PMany<Self>

Match this parser one or more times and collect the results.

fn delimited_by<PD, A>(self, delim: PD) -> PDelim<Self, PD, A>

where A: Clone + 'a, PD: Parser<'a, K, A>,

Parse this parser zero or more times separated by a delimiter (but keep only the content values). By defualt allow trailing delimiters use crate::parser::delim::PDelim::no_trailing, crate::parser::delim::PDelim::at_least and crate::parser::delim::PDelim::at_most to specialize this parser.

fn delimited_by1<PD, A>(self, delim: PD) -> PDelim<Self, PD, A>

where A: Clone + 'a, PD: Parser<'a, K, A>,

Parse this parser one or more times separated by a delimiter (but keep only the content values).

fn not(self) -> PNot<Self, O>

Succeeds only if this parser fails, and vice versa. Produces no value.

fn padded_by<PD, A>(self, pad: PD) -> PPaddedBy<Self, PD, A>

where A: Clone + 'a, PD: Parser<'a, K, A> + Clone,

Surround this parser with padding (like whitespace) and return the result.

fn into_<Out>(self, out: Out) -> PInto<Self, O, Out, K>

where Out: PartialEq + Clone + 'a,

Ignores the actual parsed value and replaces it with a given one.

fn debug(self, label: &'static str) -> PDebug<Self>

where K: ErrorDisplay,

Debug tracing combinator to help inspect parsing behavior.

fn and<P2, A>(self, second: P2) -> PAnd<Self, P2, A>

where A: Clone + 'a, P2: Parser<'a, K, A>,

Apply another parser after this one, but return only the result of the first as well as the location after parsing.

fn until_end(self) -> PUntilEnd<Self, K>

Succeeds if and only if the inner parser succeeds and consumes all input

fn foldl<TP, F, I, O2>(self, tail: TP, f: F) -> PFoldLeft<Self, TP, F, I, O2>

where O2: Clone + 'a, I: IntoIterator<Item = O2> + Clone + 'a, TP: Parser<'a, K, I>, F: Fn(O, O2) -> O + Clone + 'a,

Use self as init while folding left on tail using f

fn ignore_then<P2, OO>(self, then: P2) -> PIgnoreThen<Self, P2, O>

where OO: Clone + 'a, P2: Parser<'a, K, OO>,

Parsers two parsers in sequence ignores the result of the first and returns the result of the second

fn then_ignore<P2, OI>(self, ignore: P2) -> PThenIgnore<Self, P2, OI>

where OI: Clone + 'a, P2: Parser<'a, K, OI>,

Parsers two parsers in sequence returns the result of the first and ignores the result of the second

fn map_with_span<F, O2>(self, f: F) -> PMapWithSpan<Self, O, O2>

where F: Fn(O, Span) -> O2 + 'static, O2: Clone + 'a,

Map the result of the parser through a function with the span which the parser was successful parsing

fn map_error<F>(self, f: F) -> PMapError<'a, K, Self>

where F: Fn(Error<'a, K>) -> Error<'a, K> + 'static,

Map an error of self with f if it fails else result the result of self

impl<'a, P, K, O1, O2> ParserCore<'a, K, O2> for PBind<P, O1, O2>

where K: PartialEq + Clone + 'a, O1: Clone + 'a, P: Parser<'a, K, O1>,

fn parse(&self, i: PInput<'a, K>) -> Result<PSuccess<'a, K, O2>, Error<'a, K>>

Applies the inner parser, then transforms its result using the function f.

If parsing succeeds, the transformation function is applied to the result, and the transformed value is returned.

Errors

Returns a parse failure if the inner parser p fails.