Enum winnow::error::ErrMode

pub enum ErrMode<E> {
    Incomplete(Needed),
    Backtrack(E),
    Cut(E),
}

Add parse error state to ParserErrors

Variants

Incomplete(Needed)

There was not enough data to determine the appropriate action

More data needs to be buffered before retrying the parse.

This must only be set when the Stream is partial, like with Partial

Convert this into an Backtrack with Parser::complete_err

Backtrack(E)

The parser failed with a recoverable error (the default).

For example, a parser for json values might include a dec_uint as one case in an alt combiantor. If it fails, the next case should be tried.

Cut(E)

The parser had an unrecoverable error.

The parser was on the right branch, so directly report it to the user rather than trying other branches. You can use cut_err() combinator to switch from ErrMode::Backtrack to ErrMode::Cut.

For example, one case in an alt combinator found a unique prefix and you want any further errors parsing the case to be reported to the user.

Implementations

impl<E> ErrMode<E>

pub fn is_incomplete(&self) -> bool

Tests if the result is Incomplete

pub fn cut(self) -> Self

Prevent backtracking, bubbling the error up to the top

pub fn backtrack(self) -> Self

Enable backtracking support

pub fn map<E2, F>(self, f: F) -> ErrMode<E2>

where F: FnOnce(E) -> E2,

Applies the given function to the inner error

pub fn convert<F>(self) -> ErrMode<F>

where E: ErrorConvert<F>,

Automatically converts between errors if the underlying type supports it

pub fn into_inner(self) -> Option<E>

Unwrap the mode, returning the underlying error

Returns None for ErrMode::Incomplete

impl<T: Clone> ErrMode<InputError<T>>

pub fn map_input<U: Clone, F>(self, f: F) -> ErrMode<InputError<U>>

where F: FnOnce(T) -> U,

Maps ErrMode<InputError<T>> to ErrMode<InputError<U>> with the given F: T -> U

Trait Implementations

impl<I, C, E: AddContext<I, C>> AddContext<I, C> for ErrMode<E>

fn add_context(self, input: &I, ctx: C) -> Self

Append to an existing error custom data

impl<E: Clone> Clone for ErrMode<E>

fn clone(&self) -> ErrMode<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for ErrMode<E>

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

Formats the value using the given formatter.

impl<E> Display for ErrMode<E>

where E: Debug,

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

Formats the value using the given formatter.

impl<I, EXT, E> FromExternalError<I, EXT> for ErrMode<E>

where E: FromExternalError<I, EXT>,

fn from_external_error(input: &I, kind: ErrorKind, e: EXT) -> Self

Like ParserError::from_error_kind but also include an external error.

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

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

Creates an error from the input position and an ErrorKind

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

where I: Debug,

Process a parser assertion

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

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

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

Combines errors from two different parse branches.

impl<E: PartialEq> PartialEq for ErrMode<E>

fn eq(&self, other: &ErrMode<E>) -> 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<E: Eq> Eq for ErrMode<E>

impl<E> StructuralPartialEq for ErrMode<E>