Struct combine_language::WhiteSpace

pub struct WhiteSpace<'a: 'b, 'b, I> where I: Stream<Item=char> + 'b {
    // some fields omitted
}

A whitespace parser for a language

Trait Implementations

impl<'a: 'b, 'b, I: Clone> Clone for WhiteSpace<'a, 'b, I> where I: Stream<Item=char> + 'b

fn clone(&self) -> WhiteSpace<'a, 'b, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b, I> Parser for WhiteSpace<'a, 'b, I> where I: Stream<Item=char> + 'b

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 = ()

The type which is returned if the parser is successful.

fn parse_stream(&mut self, input: I) -> ParseResult<(), I>

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(&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_consumed(&mut self, input: Self::Input) -> FastResult<(Self::Output, Self::Input), ParseError<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_lazy(&mut self, input: Self::Input) -> FastResult<(Self::Output, Self::Input), ParseError<Self::Input>>

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, _error: &mut ParseError<Self::Input>)

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

fn with<P2>(self, p: P2) -> With<Self, P2> where 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 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 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 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 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 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 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 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 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 E: Into<Error<Self::Input::Item, Self::Input::Range>>, F: FnMut(Self::Output) -> Result<O, E>

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>

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