Struct combine::parser::combinator::AndThen

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

Trait Implementations

impl<P, F, O, E, I> Parser for AndThen<P, F> where     I: Stream,     P: Parser<Input = I>,     F: FnMut(P::Output) -> Result<O, E>,     E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,     I::Error: ParseError<I::Item, I::Range, I::Position>,

type Input = P::Input

The type which is taken as input for the parser. The type must implement the Stream trait which allows the parser to read items from the type.

type Output = O

The type which is returned if the parser is successful.

type PartialState = P::PartialState

Determines the state necessary to resume parsing after more input is supplied.

fn parse_partial(     &mut self,     input: &mut Self::Input,     state: &mut Self::PartialState ) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input and allows itself to be resumed at a later point using parse_partial by storing the necessary intermediate state in state

fn parse_first(     &mut self,     input: &mut Self::Input,     state: &mut Self::PartialState ) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input and allows itself to be resumed at a later point using parse_partial by storing the necessary intermediate state in state.

fn parse_mode_impl<M>(     &mut self,     mode: M,     input: &mut Self::Input,     state: &mut Self::PartialState ) -> ConsumedResult<Self::Output, Self::Input> where     M: ParseMode,

fn add_error(&mut self, error: &mut Tracked<<Self::Input as StreamOnce>::Error>)

Adds the first error that would normally be returned by this parser if it failed with an EmptyErr result.

fn add_consumed_expected_error(     &mut self,     error: &mut Tracked<<Self::Input as StreamOnce>::Error> )

fn parser_count(&self) -> ErrorOffset

fn easy_parse<I>(     &mut self,     input: I ) -> Result<(Self::Output, I), ParseError<I>> where     I: Stream,     Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,     I::Position: Default,     Self: Sized + Parser<Input = Stream<I>>,

Entry point of the parser. Takes some input and tries to parse it, returning an easy to use and format error if parsing did not succeed.

fn parse(     &mut self,     input: Self::Input ) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>

Entry point of the parser. Takes some input and tries to parse it.

fn parse_with_state(     &mut self,     input: &mut Self::Input,     state: &mut Self::PartialState ) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>

Entry point of the parser when using partial parsing. Takes some input and tries to parse it.

fn parse_stream(     &mut self,     input: &mut Self::Input ) -> ParseResult<Self::Output, Self::Input>

Parses using the stream input by calling [Stream::uncons] one or more times.

fn parse_stream_consumed(     &mut self,     input: &mut Self::Input ) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input by calling [Stream::uncons] one or more times.

fn parse_stream_consumed_partial(     &mut self,     input: &mut Self::Input,     state: &mut Self::PartialState ) -> ConsumedResult<Self::Output, Self::Input>

fn parse_lazy(     &mut self,     input: &mut Self::Input ) -> ConsumedResult<Self::Output, Self::Input>

Parses using the stream input by calling [Stream::uncons] one or more times.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn by_ref(&mut self) -> &mut Self where     Self: Sized,

Borrows a parser instead of consuming it.

fn with<P2>(self, p: P2) -> With<Self, P2> where     Self: Sized,     P2: Parser<Input = Self::Input>,

Discards the value of the self parser and returns the value of p. Fails if any of the parsers fails.

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where     Self: Sized,     P2: Parser<Input = Self::Input>,

Discards the value of the p parser and returns the value of self. Fails if any of the parsers fails.

fn and<P2>(self, p: P2) -> (Self, P2) where     Self: Sized,     P2: Parser<Input = Self::Input>,

Parses with self followed by p. Succeeds if both parsers succeed, otherwise fails. Returns a tuple with both values on success.

fn or<P2>(self, p: P2) -> Or<Self, P2> where     Self: Sized,     P2: Parser<Input = Self::Input, Output = Self::Output>,

Returns a parser which attempts to parse using self. If self fails without consuming any input it tries to consume the same input using p.

fn then<N, F>(self, f: F) -> Then<Self, F> where     Self: Sized,     F: FnMut(Self::Output) -> N,     N: Parser<Input = Self::Input>,

Parses using self and then passes the value to f which returns a parser used to parse the rest of the input.

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where     Self: Sized,     F: FnMut(&mut Self::Output) -> N,     N: Parser<Input = Self::Input>,

Variant of then which parses using self and then passes the value to f as a &mut reference.

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

Uses f to map over the parsed value.

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where     Self: Sized,     F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>,

Uses f to map over the output of self. If f returns an error the parser fails.

fn message<S>(self, msg: S) -> Message<Self> where     Self: Sized,     S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,

Parses with self and if it fails, adds the message msg to the error.

fn expected<S>(self, msg: S) -> Expected<Self> where     Self: Sized,     S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>,

Parses with self and if it fails without consuming any input any expected errors are replaced by msg. msg is then used in error messages as "Expected msg".

fn silent(self) -> Silent<Self> where     Self: Sized,

Parses with self, if it fails without consuming any input any expected errors that would otherwise be emitted by self are suppressed.

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where     Self: Parser<Input = I> + Sized,     F: FnMut(Self::Output) -> Result<O, E>,     I: Stream,     E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>,

Parses with self and applies f on the result if self parses successfully. f may optionally fail with an error which is automatically converted to a ParseError.

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn iter(     self,     input: &mut Self::Input ) -> Iter<Self, Self::PartialState, FirstMode> where     Self: Parser + Sized,

Creates an iterator from a parser and a state. Can be used as an alternative to [many] when collecting directly into a Extend type is not desirable.

Important traits for Iter<'a, P, S, M>

impl<'a, P: Parser, S, M> Iterator for Iter<'a, P, S, M> where
    S: BorrowMut<P::PartialState>,
    M: ParseMode,  type Item = P::Output;

fn partial_iter<'a, 's, M>(     self,     mode: M,     input: &'a mut Self::Input,     partial_state: &'s mut Self::PartialState ) -> Iter<'a, Self, &'s mut Self::PartialState, M> where     Self: Parser + Sized,     M: ParseMode,

Creates an iterator from a parser and a state. Can be used as an alternative to [many] when collecting directly into a Extend type is not desirable.

Important traits for Box<W>

impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

fn boxed<'a>(     self ) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where     Self: Sized + 'a,

Turns the parser into a trait object by putting it in a Box. Can be used to easily return parsers from functions without naming the type.

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, 

fn left<R>(self) -> Either<Self, R> where     Self: Sized,     R: Parser<Input = Self::Input, Output = Self::Output>,

Wraps the parser into the Either enum which allows combinators such as then to return multiple different parser types (merging them to one)

Important traits for Either<L, R>

impl<L, R> Read for Either<L, R> where
    L: Read,
    R: Read, impl<L, R> Iterator for Either<L, R> where
    L: Iterator,
    R: Iterator<Item = <L as Iterator>::Item>,  type Item = <L as Iterator>::Item;impl<L, R> Write for Either<L, R> where
    L: Write,
    R: Write, 

fn right<L>(self) -> Either<L, Self> where     Self: Sized,     L: Parser<Input = Self::Input, Output = Self::Output>,

Wraps the parser into the Either enum which allows combinators such as then to return multiple different parser types (merging them to one)

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.