Enum Err

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

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. For example, when a prefix has been recognised and the next parser has been confirmed, if that parser fails, then the entire process fails; there are no more parsers to try.

Distinguishing Failure this from Error is only relevant inside the parser’s code. For external consumers, both mean that parsing failed.

See also: Finish.

Variants

Incomplete(Needed)

There was not enough data

Error(Error)

The parser had an error (recoverable)

Failure(Failure)

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

impl<E> Err<E>

pub fn is_incomplete(&self) -> bool

Tests if the result is Incomplete

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

where F: FnOnce(E) -> E2,

Applies the given function to the inner error

pub fn convert<F>(e: Err<F>) -> Err<E>

where E: From<F>,

Automatically converts between errors if the underlying type supports it

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

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

impl<T> Err<Error<T>>

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

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

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

Obtaining ownership

impl Err<(&str, ErrorKind)>

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

Obtaining ownership

impl Err<Error<&[u8]>>

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

Obtaining ownership

impl Err<Error<&str>>

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

Obtaining ownership

Trait Implementations

impl<Failure, Error> Clone for Err<Failure, Error>

where Failure: Clone, Error: Clone,

fn clone(&self) -> Err<Failure, Error>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Failure, Error> Debug for Err<Failure, Error>

where Failure: Debug, Error: Debug,

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

Formats the value using the given formatter.

impl<E> Display for Err<E>

where E: Debug,

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

Formats the value using the given formatter.

impl<E> Error for Err<E>

where E: Debug,

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

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

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

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl<Failure, Error> PartialEq for Err<Failure, Error>

where Failure: PartialEq, Error: PartialEq,

fn eq(&self, other: &Err<Failure, Error>) -> 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 for Err<E>

where E: Eq,

impl<Failure, Error> StructuralPartialEq for Err<Failure, Error>