Struct combine::combinator::Try

pub struct Try<P>(_);

Trait Implementations

impl<P: Clone> Clone for Try<P>

fn clone(&self) -> Try<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, O, P> Parser for Try<P> where I: Stream, P: Parser<Input=I, Output=O>

type Input = I

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

type Output = O

The type which is returned if the parser is successful.

fn parse_lazy(&mut self, input: I) -> ConsumedResult<O, I>

Specialized version of parse_stream where the parser does not need to add an error to the ParseError when it does not consume any input before encountering the error. Instead the error can be added later through the add_error method

fn add_error(&mut self, errors: &mut ParseError<Self::Input>)

Adds the first error that would normally be returned by this parser if it failed

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

Entrypoint of the parser Takes some input and tries to parse it returning a ParseResult

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

Parses using the stream input by calling Stream::uncons one or more times On success returns Ok((value, new_state)) on failure it returns Err(error)

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

Parses using the stream input by calling Stream::uncons one or more times On success returns Ok((value, new_state)) on failure it returns Err(error)

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 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, ParseError<Self::Input>>

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::Item, Self::Input::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::Item, Self::Input::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 and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where Self: Sized, F: FnMut(Self::Output) -> Result<O, E>, E: Into<Error<Self::Input::Item, Self::Input::Range>>

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

fn iter(self, input: Self::Input) -> Iter<Self> where Self: Sized

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