Enum combine::error::Consumed

pub enum Consumed<T> {
    Consumed(T),
    Empty(T),
}

Enum used to indicate if a parser consumed any items of the stream it was given as an input.

This is used by parsers such as or and choice to determine if they should try to parse with another parser as they will only be able to provide good error reporting if the preceding parser did not consume any tokens.

Variants

Consumed(T)

Constructor indicating that the parser has consumed elements

Empty(T)

Constructor indicating that the parser did not consume any elements

Methods

impl<T> Consumed<T>

pub fn is_empty(&self) -> bool

Returns true if self is empty.

pub fn into_inner(self) -> T

Extracts the contained value.

pub fn into_consumed(self) -> Consumed<T>

Converts self into the Consumed state.

pub fn into_empty(self) -> Consumed<T>

Converts self into the Empty state.

pub fn map<F, U>(self, f: F) -> Consumed<U> where
    F: FnOnce(T) -> U, 

Maps over the contained value without changing the consumed state.

pub fn merge(&self, current: Consumed<T>) -> Consumed<T>

pub fn combine<F, U, E>(self, f: F) -> StdParseResult2<U, E> where
    F: FnOnce(T) -> StdParseResult2<U, E>, 

Combines the Consumed flags from self and the result of f.

Empty    <> Empty    -> Empty
Consumed <> Empty    -> Consumed
Empty    <> Consumed -> Consumed
Consumed <> Consumed -> Consumed

//Parses a character of string literal and handles the escaped characters \\ and \" as \
//and " respectively
fn char<Input>(input: &mut Input) -> StdParseResult<char, Input>
    where Input: Stream<Token = char>,
          Input::Error: ParseError<Input::Token, Input::Range, Input::Position>,
{
    let (c, consumed) = satisfy(|c| c != '"').parse_stream(input).into_result()?;
    match c {
        //Since the `char` parser has already consumed some of the input `combine` is used
        //propagate the consumed state to the next part of the parser
        '\\' => consumed.combine(|_| {
            satisfy(|c| c == '"' || c == '\\')
                .map(|c| {
                    match c {
                        '"' => '"',
                        '\\' => '\\',
                        c => c
                    }
                })
                .parse_stream(input)
                .into_result()
            }),
        _ => Ok((c, consumed))
    }
}
let result = many(parser(char))
    .easy_parse(r#"abc\"\\"#);
assert_eq!(result, Ok((r#"abc"\"#.to_string(), "")));
}

pub fn combine_consumed<F, U, E>(self, f: F) -> ParseResult<U, E> where
    F: FnOnce(T) -> ParseResult<U, E>, 

Trait Implementations

impl<T> AsRef<T> for Consumed<T>

Important traits for &'_ mut W

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

fn as_ref(&self) -> &T

Performs the conversion.

impl<T> AsMut<T> for Consumed<T>

Important traits for &'_ mut W

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

fn as_mut(&mut self) -> &mut T

Performs the conversion.

impl<T: Clone> Clone for Consumed<T>

fn clone(&self) -> Consumed<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Consumed<T>

impl<T: PartialEq> PartialEq<Consumed<T>> for Consumed<T>

fn eq(&self, other: &Consumed<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Consumed<T>) -> bool

This method tests for !=.

impl<T: Debug> Debug for Consumed<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.