Trait ParserError

pub trait ParserError<I: Stream>: Sized {
    // Required methods
    fn from_error_kind(input: &I, kind: ErrorKind) -> Self;
    fn append(
        self,
        input: &I,
        token_start: &<I as Stream>::Checkpoint,
        kind: ErrorKind,
    ) -> Self;

    // Provided methods
    fn assert(input: &I, _message: &'static str) -> Self
       where I: Debug { ... }
    fn or(self, other: Self) -> Self { ... }
}

The basic Parser trait for errors

It provides methods to create an error from some combinators, and combine existing errors in combinators like alt.

Required Methods

fn from_error_kind(input: &I, kind: ErrorKind) -> Self

Creates an error from the input position and an ErrorKind

fn append( self, input: &I, token_start: &<I as Stream>::Checkpoint, kind: ErrorKind, ) -> Self

Like ParserError::from_error_kind but merges it with the existing error.

This is useful when backtracking through a parse tree, accumulating error context on the way.

Provided Methods

fn assert(input: &I, _message: &'static str) -> Self

where I: Debug,

Process a parser assertion

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

Combines errors from two different parse branches.

For example, this would be used by alt to report the error from each case.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<I: Stream> ParserError<I> for ()

fn from_error_kind(_: &I, _: ErrorKind) -> Self

fn append( self, _input: &I, _token_start: &<I as Stream>::Checkpoint, _kind: ErrorKind, ) -> Self

Implementors

impl<I, C> ParserError<I> for TreeError<I, C>

where I: Stream + Clone,

impl<I: Stream + Clone> ParserError<I> for InputError<I>

impl<I: Stream> ParserError<I> for ErrorKind

impl<I: Stream, C> ParserError<I> for ContextError<C>

impl<I: Stream, E: ParserError<I>> ParserError<I> for ErrMode<E>