[][src]Enum nom_whitespace::lib::nom::Err

pub enum Err<I, E = u32> {
    Error(Context<I, E>),
    Failure(Context<I, E>),

The Err enum indicates the parser was not successful

It has three cases:

  • Incomplete indicates that more data is needed to decide. The Needed enum can contain how many additional bytes are necessary. If you are sure your parser is working on full data, you can wrap your parser with the complete combinator to transform that case in Error
  • Error means some parser did not succeed, but another one might (as an example, when testing different branches of an alt combinator)
  • Failure indicates an unrecoverable error. As an example, if you recognize a prefix to decide on the next parser to apply, and that parser fails, you know there's no need to try other parsers, you were already in the right branch, so the data is invalid

Depending on a compilation flag, the content of the Context enum can change. In the default case, it will only have one variant: Context::Code(I, ErrorKind<E=u32>) (with I and E configurable). It contains an error code and the input position that triggered it.

If you activate the verbose-errors compilation flags, it will add another variant to the enum: Context::List(Vec<(I, ErrorKind<E>)>). This variant aggregates positions and error codes as the code backtracks through the nested parsers. The verbose errors feature allows for very flexible error management: you can know precisely which parser got to which part of the input. The main drawback is that it is a lot slower than default error management.



There was not enough data

Error(Context<I, E>)

The parser had an error (recoverable)

Failure(Context<I, E>)

The parser had an unrecoverable error: we got to the right branch and we know other branches won't work, so backtrack as fast as possible


impl<I, E> Err<I, E>[src]

pub fn into_error_kind(self) -> ErrorKind<E>[src]

pub fn is_incomplete(&self) -> bool[src]

Trait Implementations

impl<I, H, F, E> Convert<Err<I, F>> for Err<H, E> where
    E: From<F>,
    H: From<I>, 

impl<I, E> Debug for Err<I, E> where
    E: Debug,
    I: Debug

impl<I, E> Clone for Err<I, E> where
    E: Clone,
    I: Clone

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

Performs copy-assignment from source. Read more

impl<I, E> Error for Err<I, E> where
    E: Debug,
    I: Debug

default fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more

default fn type_id(&self) -> TypeId where
    Self: 'static, 

Gets the TypeId of self

impl<I, E> PartialEq<Err<I, E>> for Err<I, E> where
    E: PartialEq<E>,
    I: PartialEq<I>, 

impl<I, E> Display for Err<I, E> where
    E: Debug,
    I: Debug

Auto Trait Implementations

impl<I, E> Send for Err<I, E> where
    E: Send,
    I: Send

impl<I, E> Sync for Err<I, E> where
    E: Sync,
    I: Sync

Blanket Implementations

impl<T> From for T[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T, U> Into for T where
    U: From<T>, 

impl<T> Borrow for T where
    T: ?Sized

impl<T> BorrowMut for T where
    T: ?Sized

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> ToOwned for T where
    T: Clone

type Owned = T

impl<T> ToString for T where
    T: Display + ?Sized