Trait combine::error::ParseError

pub trait ParseError<Item, Range, Position>: Sized + PartialEq {
    type StreamError: StreamError<Item, Range>;

    fn empty(position: Position) -> Self;
    fn set_position(&mut self, position: Position);
    fn add(&mut self, err: Self::StreamError);
    fn set_expected<F>(self_: &mut Tracked<Self>, info: Self::StreamError, f: F)
    where
        F: FnOnce(&mut Tracked<Self>);
    fn is_unexpected_end_of_input(&self) -> bool;
    fn into_other<T>(self) -> T
    where
        T: ParseError<Item, Range, Position>;

    fn from_error(position: Position, err: Self::StreamError) -> Self { ... }
    fn position(&self) -> Position { ... }
    fn merge(self, other: Self) -> Self { ... }
    fn add_expected<E>(&mut self, info: E)
    where
        E: for<'s> ErrorInfo<'s, Item, Range>,
    { ... }
    fn add_unexpected<E>(&mut self, info: E)
    where
        E: for<'s> ErrorInfo<'s, Item, Range>,
    { ... }
    fn add_message<E>(&mut self, info: E)
    where
        E: for<'s> ErrorInfo<'s, Item, Range>,
    { ... }
    fn clear_expected(&mut self) { ... }
}

Trait which defines a combine parse error.

A parse error is composed of zero or more StreamError instances which gets added to it as errors are encountered during parsing.

Required Associated Types

type StreamError: StreamError<Item, Range>

Required Methods

fn empty(position: Position) -> Self

Constructs an empty error.

An empty error is expected to be cheap to create as it is frequently created and discarded.

fn set_position(&mut self, position: Position)

Sets the position of this ParseError

fn add(&mut self, err: Self::StreamError)

Adds a StreamError to self.

It is up to each individual error type to define what adding an error does, some may push it to a vector while others may only keep self or err to avoid allocation

fn set_expected<F>(self_: &mut Tracked<Self>, info: Self::StreamError, f: F) where
    F: FnOnce(&mut Tracked<Self>), 

Sets info as the only Expected error of self

fn is_unexpected_end_of_input(&self) -> bool

fn into_other<T>(self) -> T where
    T: ParseError<Item, Range, Position>, 

Does a best-effort conversion of self into another ParseError

Provided Methods

fn from_error(position: Position, err: Self::StreamError) -> Self

Creates a ParseError from a single Self::StreamError

fn position(&self) -> Position

fn merge(self, other: Self) -> Self

Merges two errors. If they exist at the same position the errors of other are added to self (using the semantics of add). If they are not at the same position the error furthest ahead are returned, ignoring the other ParseError.

fn add_expected<E>(&mut self, info: E) where
    E: for<'s> ErrorInfo<'s, Item, Range>, 

fn add_unexpected<E>(&mut self, info: E) where
    E: for<'s> ErrorInfo<'s, Item, Range>, 

fn add_message<E>(&mut self, info: E) where
    E: for<'s> ErrorInfo<'s, Item, Range>, 

fn clear_expected(&mut self)

Removes any expected errors currently in self

Implementors

impl<Item, Range, Position> ParseError<Item, Range, Position> for combine::stream::easy::Error<Item, Range> where
    Item: PartialEq,
    Range: PartialEq,
    Position: Default, 

type StreamError = Error<Item, Range>

impl<Item, Range, Position> ParseError<Item, Range, Position> for combine::stream::read::Error where
    Position: Default, 

type StreamError = Error

impl<Item, Range, Position> ParseError<Item, Range, Position> for StringStreamError where
    Position: Default, 

type StreamError = StringStreamError

impl<Item, Range, Position> ParseError<Item, Range, Position> for UnexpectedParse where
    Position: Default, 

type StreamError = UnexpectedParse

impl<Item, Range, Position> ParseError<Item, Range, Position> for Errors<Item, Range, Position> where
    Item: PartialEq,
    Range: PartialEq,
    Position: Ord + Clone, 

type StreamError = Error<Item, Range>