Enum Commit

pub enum Commit<T> {
    Commit(T),
    Peek(T),
}

Enum used to indicate if a parser committed 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 commit to the parse.

Variants

Commit(T)

Constructor indicating that the parser has committed to this parse. If a parser after this fails, other parser alternatives will not be attempted (CommitErr will be returned)

Peek(T)

Constructor indicating that the parser has not committed to this parse. If a parser after this fails, other parser alternatives will be attempted (EmptyErr will be returned)

Implementations

impl<T> Commit<T>

pub fn is_peek(&self) -> bool

Returns true if self is peek.

pub fn into_inner(self) -> T

Extracts the contained value.

pub fn into_commit(self) -> Commit<T>

Converts self into the Commit state.

pub fn into_peek(self) -> Commit<T>

Converts self into the Peek state.

pub fn map<F, U>(self, f: F) -> Commit<U>

where F: FnOnce(T) -> U,

Maps over the contained value without changing the committed state.

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

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

where F: FnOnce(T) -> StdParseResult2<U, E>,

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

Peek    <> Peek    -> Peek
Commit <> Peek    -> Commit
Peek    <> Commit -> Commit
Commit <> Commit -> Commit

//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>,
{
    let (c, committed) = satisfy(|c| c != '"').parse_stream(input).into_result()?;
    match c {
        //Since the `char` parser has already committed some of the input `combine` is used
        //propagate the committed state to the next part of the parser
        '\\' => committed.combine(|_| {
            satisfy(|c| c == '"' || c == '\\')
                .map(|c| {
                    match c {
                        '"' => '"',
                        '\\' => '\\',
                        c => c
                    }
                })
                .parse_stream(input)
                .into_result()
            }),
        _ => Ok((c, committed))
    }
}
let result = many(parser(char))
    .easy_parse(r#"abc\"\\"#);
assert_eq!(result, Ok((r#"abc"\"#.to_string(), "")));
}

pub fn combine_commit<F, U, E>(self, f: F) -> ParseResult<U, E>

where F: FnOnce(T) -> ParseResult<U, E>,

Trait Implementations

impl<T> AsMut<T> for Commit<T>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<T> for Commit<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Commit<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Commit<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Commit<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy> Copy for Commit<T>

impl<T> StructuralPartialEq for Commit<T>