Struct parsell::impls::AndThen

pub struct AndThen<P, Q>(_, _);

Methods

impl<P, Q> AndThen<P, Q>

fn new(p: P, q: Q) -> Self

Trait Implementations

impl<P: Copy, Q: Copy> Copy for AndThen<P, Q>

impl<P: Clone, Q: Clone> Clone for AndThen<P, Q>

fn clone(&self) -> AndThen<P, Q>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, Q: Debug> Debug for AndThen<P, Q>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<P, Q> Parser for AndThen<P, Q>

fn or_else<P>(self, other: P) -> OrElse<Self, P> where
    Self: Sized,
    P: Parser, 

Choice between parsers

fn and_then<P>(self, other: P) -> AndThen<Self, P> where
    Self: Sized,
    P: Parser, 

Sequencing with a committed parser

fn try_and_then<P>(self, other: P) -> Map<AndThen<Self, P>, TryZip> where
    Self: Sized,
    P: Parser, 

Sequencing with a committed parser (bubble any errors from this parser).

fn and_then_try<P>(self, other: P) -> Map<AndThen<Self, P>, ZipTry> where
    Self: Sized,
    P: Parser, 

Sequencing with a committed parser (bubble any errors from that parser).

fn try_and_then_try<P>(
    self,
    other: P
) -> VariantMap<AndThen<Self, P>, TryZipTry> where
    Self: Sized,
    P: Parser, 

Sequencing with a committed parser (bubble any errors from either parser).

fn plus<F>(self, factory: F) -> Plus<Self, F> where
    Self: Sized,
    F: Factory, 

Iterate one or more times (returns an uncommitted parser).

fn star<F>(self, factory: F) -> Star<Self, F> where
    Self: Sized,
    F: Factory, 

Iterate zero or more times (returns a committed parser).

fn map<F>(self, f: F) -> Map<Self, F> where
    Self: Sized, 

Apply a function to the result

fn map2<F>(self, f: F) -> Map<Self, Function2<F>> where
    Self: Sized, 

Apply a 2-arguent function to the result

fn map3<F>(self, f: F) -> Map<Self, Function3<F>> where
    Self: Sized, 

Apply a 3-arguent function to the result

fn map4<F>(self, f: F) -> Map<Self, Function4<F>> where
    Self: Sized, 

Apply a 4-arguent function to the result

fn map5<F>(self, f: F) -> Map<Self, Function5<F>> where
    Self: Sized, 

Apply a 5-arguent function to the result

fn map6<F>(self, f: F) -> Map<Self, Function6<F>> where
    Self: Sized, 

Apply a 6-arguent function to the result

fn try_map<F>(self, f: F) -> Map<Self, Try<F>> where
    Self: Sized, 

Apply a function to the result (bubble any errors).

fn try_map2<F>(self, f: F) -> Map<Self, Try<Function2<F>>> where
    Self: Sized, 

Apply a 2-argument function to the result (bubble any errors).

fn try_map3<F>(self, f: F) -> Map<Self, Try<Function3<F>>> where
    Self: Sized, 

Apply a 3-argument function to the result (bubble any errors).

fn try_map4<F>(self, f: F) -> Map<Self, Try<Function4<F>>> where
    Self: Sized, 

Apply a 4-argument function to the result (bubble any errors).

fn try_map5<F>(self, f: F) -> Map<Self, Try<Function5<F>>> where
    Self: Sized, 

Apply a 5-argument function to the result (bubble any errors).

fn try_map6<F>(self, f: F) -> Map<Self, Try<Function6<F>>> where
    Self: Sized, 

Apply a 6-argument function to the result (bubble any errors).

fn map_ref<F>(self, f: F) -> Map<Self, Dereference<F>> where
    Self: Sized, 

Apply a by-reference function to the result

fn variant_map<F>(self, f: F) -> VariantMap<Self, F> where
    Self: Sized, 

Apply a variant function to the result

fn discard_and_then<P>(
    self,
    other: P
) -> VariantMap<AndThen<Discard<Self>, P>, Second> where
    Self: Sized,
    P: Parser, 

Sequencing, discard the output of the first parse

fn and_then_discard<P>(
    self,
    other: P
) -> VariantMap<AndThen<Self, Discard<P>>, First> where
    Self: Sized,
    P: Parser, 

Sequencing, discard the output of the second parse

fn try_discard_and_then<P>(
    self,
    other: P
) -> VariantMap<Map<AndThen<Map<Self, TryDiscard>, P>, TryZip>, Try<Second>> where
    Self: Sized,
    P: Parser, 

Sequencing, discard the output of the first parse, bubble errors from the first parser

fn and_then_try_discard<P>(
    self,
    other: P
) -> VariantMap<Map<AndThen<Self, Map<P, TryDiscard>>, ZipTry>, Try<First>> where
    Self: Sized,
    P: Parser, 

Sequencing, discard the output of the second parse, bubble errors from the second parser

fn try_discard_and_then_try<P>(
    self,
    other: P
) -> VariantMap<VariantMap<AndThen<Map<Self, TryDiscard>, P>, TryZipTry>, Try<Second>> where
    Self: Sized,
    P: Parser, 

Sequencing, discard the output of the first parse, bubble errors from either parser

fn try_and_then_try_discard<P>(
    self,
    other: P
) -> VariantMap<VariantMap<AndThen<Self, Map<P, TryDiscard>>, TryZipTry>, Try<First>> where
    Self: Sized,
    P: Parser, 

Sequencing, discard the output of the second parse, bubble errors from either parser

fn opt(self) -> Opt<Self> where
    Self: Sized, 

Optional parse

fn try_opt(self) -> VariantMap<Opt<Self>, TryOpt> where
    Self: Sized, 

Optional parse

fn discard(self) -> Discard<Self> where
    Self: Sized, 

Discard the output

fn try_discard(self) -> Map<Self, TryDiscard> where
    Self: Sized, 

Discard the output, bubbling errors

fn boxed<F>(self, f: F) -> Boxed<Self, F> where
    Self: Sized, 

Box up this parser

fn in_state<State>(self, state: State) -> InState<Self, State> where
    Self: Sized, 

Set the state of this parser

fn buffer(self) -> Buffered<Self> where
    Self: Sized, 

A parser which produces its input.

impl<P, Q, Ch, Str, POutput, PStaticOutput, QOutput> Committed<Ch, Str, (POutput, QOutput)> for AndThen<P, Q> where
    P: Committed<Ch, Str, POutput>,
    Q: 'static + Copy + Committed<Ch, Str, QOutput>,
    POutput: ToStatic<Static = PStaticOutput> + Downcast<PStaticOutput>, 

fn empty(&self) -> (POutput, QOutput)

Parse an EOF.

impl<P, Q, Ch, Str, POutput, PStaticOutput, QOutput> Uncommitted<Ch, Str, (POutput, QOutput)> for AndThen<P, Q> where
    P: Uncommitted<Ch, Str, POutput>,
    Q: 'static + Copy + Committed<Ch, Str, QOutput>,
    POutput: ToStatic<Static = PStaticOutput> + Downcast<PStaticOutput>, 

type State = AndThenState<P::State, Q, PStaticOutput, Q::State>

fn init(
    &self,
    string: &mut Str
) -> Option<ParseResult<Self::State, (POutput, QOutput)>>

Parse a string of data.

impl<P, Q, Ch, Str> HasOutput<Ch, Str> for AndThen<P, Q> where
    P: HasOutput<Ch, Str>,
    Q: HasOutput<Ch, Str>, 

type Output = (P::Output, Q::Output)

The type of the data being produced by the parser.