# Enum nom::Err

source · [−]

    pub enum Err<E> {
        Incomplete(Needed),
        Error(E),
        Failure(E),
    }

Expand description

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

## Variants

### `Incomplete(Needed)`

There was not enough data

### `Error(E)`

The parser had an error (recoverable)

### `Failure(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

## Implementations

source

### impl<E> Err<E>

source

#### pub fn is_incomplete(&self) -> bool

Tests if the result is Incomplete

source

#### pub fn map<E2, F>(self, f: F) -> Err<E2> where
F: FnOnce(E) -> E2,

Applies the given function to the inner error

source

#### pub fn convert<F>(e: Err<F>) -> Self where
E: From<F>,

Automatically converts between errors if the underlying type supports it

source

### impl<T> Err<(T, ErrorKind)>

source

#### pub fn map_input<U, F>(self, f: F) -> Err<(U, ErrorKind)> where
F: FnOnce(T) -> U,

Maps `Err<(T, ErrorKind)>` to `Err<(U, ErrorKind)>` with the given `F: T -> U`

source

### impl<T> Err<Error<T>>

source

#### pub fn map_input<U, F>(self, f: F) -> Err<Error<U>> where
F: FnOnce(T) -> U,

Maps `Err<error::Error<T>>` to `Err<error::Error<U>>` with the given `F: T -> U`

source

### impl Err<(&[u8], ErrorKind)>

source

#### pub fn to_owned(self) -> Err<(Vec<u8>, ErrorKind)>

Obtaining ownership

source

### impl Err<(&str, ErrorKind)>

source

#### pub fn to_owned(self) -> Err<(String, ErrorKind)>

Obtaining ownership

source

### impl Err<Error<&[u8]>>

source

#### pub fn to_owned(self) -> Err<Error<Vec<u8>>>

Obtaining ownership

source

### impl Err<Error<&str>>

source

#### pub fn to_owned(self) -> Err<Error<String>>

Obtaining ownership

## Trait Implementations

source

### impl<E: Clone> Clone for Err<E>

source

#### fn clone(&self) -> Err<E>

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl<E: Debug> Debug for Err<E>

source

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

Formats the value using the given formatter. Read more

source

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

source

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

Formats the value using the given formatter. Read more

source

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

source

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

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

1.0.0 · source

#### fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

Read more
1.0.0 · source

#### fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

source

#### fn provide(&'a self, req: &mut Demand<'a>)

🔬 This is a nightly-only experimental API. (`error_generic_member_access`)

Provides type based access to context intended for error reports. Read more

source

### impl<E: PartialEq> PartialEq<Err<E>> for Err<E>

source

#### fn eq(&self, other: &Err<E>) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

source

#### fn ne(&self, other: &Err<E>) -> bool

This method tests for `!=`.

source

### impl<E: Eq> Eq for Err<E>

source

### impl<E> StructuralPartialEq for Err<E>

## Auto Trait Implementations

### impl<E> RefUnwindSafe for Err<E> where
E: RefUnwindSafe,

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

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

### impl<E> Unpin for Err<E> where
E: Unpin,

### impl<E> UnwindSafe for Err<E> where
E: UnwindSafe,

## Blanket Implementations

source

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

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

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

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

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

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

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

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

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

source

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more

source

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

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

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

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

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.