Struct combpop::combinators::Concat2

pub struct Concat2<P0, P1>(_, _)
 where
    P0: ParserBase,
    P1: ParserBase<Input = P0::Input>;

Trait Implementations

impl<P0, P1> ParserBase for Concat2<P0, P1> where
    P0: ParserBase,
    P1: ParserBase<Input = P0::Input>, 

type Input = P0::Input

The input type of the parser. u8 for byte-eating parsers.

type Output = (P0::Output, P1::Output)

The output type which this monadic parser produces.

fn emptiable() -> bool

Whether the parser "usually" accepts the empty sequence. Only used in emit_expectations.

fn map_once<O, F>(self, f: F) -> Map<O, Self, F> where
    Self: Sized,
    F: FnOnce(Self::Output) -> O, 

Converts a semantic value after parsing. Similar to ParserBase::map, but accepts FnOnce closures.

fn map_mut<O, F>(self, f: F) -> Map<O, Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> O, 

Converts a semantic value after parsing. Similar to ParserBase::map, but accepts FnMut closures.

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

Converts a semantic value after parsing.

fn and_then_once<P, F>(self, f: F) -> AndThen<Self, P, F> where
    Self: Sized,
    P: ParserBase<Input = Self::Input>,
    F: FnOnce(Self::Output) -> P, 

Monadic operator: run another parser f(x) after parsing. Similar to ParserBase::and_then, but accepts FnOnce closures.

fn and_then_mut<P, F>(self, f: F) -> AndThen<Self, P, F> where
    Self: Sized,
    P: ParserBase<Input = Self::Input>,
    F: FnMut(Self::Output) -> P, 

Monadic operator: run another parser f(x) after parsing. Similar to ParserBase::and_then, but accepts FnMut closures.

fn and_then<P, F>(self, f: F) -> AndThen<Self, P, F> where
    Self: Sized,
    P: ParserBase<Input = Self::Input>,
    F: Fn(Self::Output) -> P, 

Monadic operator: run another parser f(x) after parsing.

fn concat<P>(self, p: P) -> Concat2<Self, P> where
    Self: Sized,
    P: ParserBase<Input = Self::Input>, 

Applicative operator: run another parser p after parsing. The result is a pair of the result of the parsers.

fn or<P>(self, p: P) -> Choice2<Self, P> where
    Self: Sized,
    P: ParserBase<Input = Self::Input, Output = Self::Output>, 

If the parser failed without consumption, try another parser.

fn many1(self) -> Many1<Self> where
    Self: Sized, 

Returns a ParserIteratorBase that collects one or more objects from this parser.

impl<S: ?Sized, P0, P1> ParserOnce<S> for Concat2<P0, P1> where
    S: Stream<Item = P0::Input>,
    P0: ParserOnce<S>,
    P1: ParserOnce<S, Input = P0::Input>, 

fn parse_lookahead_once(
    self,
    stream: &mut S
) -> ParseResult<Option<(Self::Output, Consume)>>

fn emit_expectations(&self, stream: &mut S)

impl<S: ?Sized, P0, P1> ParserMut<S> for Concat2<P0, P1> where
    S: Stream<Item = P0::Input>,
    P0: ParserMut<S>,
    P1: ParserMut<S, Input = P0::Input>, 

fn parse_lookahead_mut(
    &mut self,
    stream: &mut S
) -> ParseResult<Option<(Self::Output, Consume)>>

fn parse_mut(&mut self, stream: &mut S) -> ParseResult<Self::Output>

fn parse_consume_mut(
    &mut self,
    stream: &mut S
) -> ParseResult<(Self::Output, Consume)>

impl<S: ?Sized, P0, P1> Parser<S> for Concat2<P0, P1> where
    S: Stream<Item = P0::Input>,
    P0: Parser<S>,
    P1: Parser<S, Input = P0::Input>, 

fn parse_lookahead(
    &self,
    stream: &mut S
) -> ParseResult<Option<(Self::Output, Consume)>>

fn parse(&self, stream: &mut S) -> ParseResult<Self::Output>

fn parse_consume(&self, stream: &mut S) -> ParseResult<(Self::Output, Consume)>