Enum combine::primitives::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

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>

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

fn as_ref(&self) -> &T

fn is_empty(&self) -> bool

Returns true if self is empty

fn into_inner(self) -> T

Extracts the contained value

fn as_consumed(self) -> Consumed<T>

Converts self into the Consumed state

fn as_empty(self) -> Consumed<T>

Converts self into theEmpty state

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

Maps over the contained value without changing the consumed state

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

fn combine<F, U, I>(self, f: F) -> ParseResult<U, I> where F: FnOnce(T) -> ParseResult<U, I>, I: StreamOnce

Combines the Consumed flags from self and the result of f

//Parses a character of string literal and handles the escaped characters \\ and \" as \
//and " respectively
fn char(input: &str) -> ParseResult<char, &str> {
    let (c, input) = try!(satisfy(|c| c != '"').parse_stream(input));
    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
        '\\' => input.combine(|input| {
            satisfy(|c| c == '"' || c == '\\')
                .map(|c| {
                    match c {
                        '"' => '"',
                        '\\' => '\\',
                        c => c
                    }
                })
                .parse_stream(input)
            }),
        _ => Ok((c, input))
    }
}
let result = many(parser(char))
    .parse(r#"abc\"\\"#);
assert_eq!(result, Ok((r#"abc"\"#.to_string(), "")));
}

fn combine_consumed<F, U, I>(self, f: F) -> ConsumedResult<U, I> where F: FnOnce(T) -> ConsumedResult<U, I>, I: StreamOnce

Trait Implementations

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: PartialEq> PartialEq for Consumed<T>

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

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

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

This method tests for !=.

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

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

Formats the value using the given formatter.

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