Struct PFoldLeft 

pub struct PFoldLeft<P, TP, F, I, O2> { /* private fields */ }

A parser combinator that applies left-associative folding.

PFoldLeft takes three parsers:

• head: a parser that produces the initial value (O)
• tail: a parser that produces an iterable of additional values (O2)
• f: Fn(O, O2) -> O.

This is useful for building left-associative constructs such as arithmetic expressions like 1 - 2 - 3 which should parse as ((1 - 2) - 3).

Type Parameters

• P: Parser for the head element (left-most value).
• TP: Parser for the tail elements (right-side iterable).
• F: The folding function applied from left to right.
• I: The iterable type returned by the tail parser.
• O2: The item type inside the tail iterable.

Trait Implementations

impl<P: Clone, TP: Clone, F: Clone, I: Clone, O2: Clone> Clone for PFoldLeft<P, TP, F, I, O2>

fn clone(&self) -> PFoldLeft<P, TP, F, I, O2>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, K, O, P, TP, F, I, O2> Parser<'a, K, O> for PFoldLeft<P, TP, F, I, O2>

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

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, K, O, P, TP, F, I, O2> ParserCore<'a, K, O> for PFoldLeft<P, TP, F, I, O2>

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

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

Runs the head parser, then the tail parser, and folds the results.