Struct combine_language::WhiteSpace

pub struct WhiteSpace<'a, 'b, I> where
    I: Stream<Token = char>,
    I::Error: ParseError<I::Token, I::Range, I::Position>,  { /* fields omitted */ }

A whitespace parser for a language

Trait Implementations

impl<'a, 'b, I: Clone> Clone for WhiteSpace<'a, 'b, I> where
    I: Stream<Token = char>,
    I::Error: ParseError<I::Token, I::Range, I::Position>, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b, Input> Parser<Input> for WhiteSpace<'a, 'b, Input> where
    Input: Stream<Token = char>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position>, 

type Output = ()

The type which is returned if the parser is successful.

type PartialState = ()

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

pub fn parse_lazy(&mut self, input: &mut Input) -> ParseResult<(), Input::Error>

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

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

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

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

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

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

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

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

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

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

Like parse_stream but supports partial parsing.

pub fn by_ref(&mut self) -> &mut Self

Borrows a parser instead of consuming it.

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

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

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

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

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

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

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

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

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

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

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

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

pub fn then_ref<N, F>(self, f: F) -> ThenRef<Self, F> where
    F: FnMut(&Self::Output) -> N,
    N: Parser<Input>, 

Parses using self and then passes a reference to the value to f which returns a parser used to parse the rest of the input. The value is then combined with the output of f.

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

Uses f to map over the parsed value.

pub fn map_input<F, B>(self, f: F) -> MapInput<Self, F> where
    F: FnMut(Self::Output, &mut Input) -> B, 

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

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

pub fn message<S>(self, msg: S) -> Message<Self, S> where
    S: for<'s> ErrorInfo<'s, <Input as StreamOnce>::Token, <Input as StreamOnce>::Range>, 

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

pub fn expected<S>(self, msg: S) -> Expected<Self, S> where
    S: for<'s> ErrorInfo<'s, <Input as StreamOnce>::Token, <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".

pub fn silent(self) -> Silent<Self>

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

pub fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where
    E: Into<<<Input as StreamOnce>::Error as ParseError<<Input as StreamOnce>::Token, <Input as StreamOnce>::Range, <Input as StreamOnce>::Position>>::StreamError>,
    F: FnMut(Self::Output) -> Result<O, E>,
    Self: Parser<Input>, 

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.

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

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.

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

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.

pub fn boxed<'a>(
    self
) -> Box<dyn Parser<Input, Output = Self::Output, PartialState = Self::PartialState> + 'a, Global> where
    Self: '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.

pub fn left<R>(self) -> Either<Self, R> where
    R: Parser<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)

pub fn right<L>(self) -> Either<L, Self> where
    L: Parser<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)

pub fn spanned(self) -> Spanned<Self>

Marks errors produced inside the self parser with the span from the start of the parse to the end of it.