Trait std::error::Error1.0.0[−][src]

pub trait Error: Debug + Display {
    fn description(&self) -> &str { ... }

    fn cause(&self) -> Option<&Error> { ... }
}

Error is a trait representing the basic expectations for error values, i.e. values of type E in Result<T, E>. Errors must describe themselves through the Display and Debug traits, and may provide cause chain information:

The cause method is generally used when errors cross "abstraction boundaries", i.e. when a one module must report an error that is "caused" by an error from a lower-level module. This setup makes it possible for the high-level module to provide its own errors that do not commit to any particular implementation, but also reveal some of its implementation for debugging via cause chains.

Provided Methods

This method is soft-deprecated.

Although using it won’t cause compilation warning, new code should use Display instead and new impls can omit it.

To obtain error description as a string, use to_string().

Examples

match "xc".parse::<u32>() {
    Err(e) => {
        // Print `e` itself, not `e.description()`.
        println!("Error: {}", e);
    }
    _ => println!("No error"),
}Run

The lower-level cause of this error, if any.

Examples

use std::error::Error;
use std::fmt;

#[derive(Debug)]
struct SuperError {
    side: SuperErrorSideKick,
}

impl fmt::Display for SuperError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SuperError is here!")
    }
}

impl Error for SuperError {
    fn description(&self) -> &str {
        "I'm the superhero of errors"
    }

    fn cause(&self) -> Option<&Error> {
        Some(&self.side)
    }
}

#[derive(Debug)]
struct SuperErrorSideKick;

impl fmt::Display for SuperErrorSideKick {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SuperErrorSideKick is here!")
    }
}

impl Error for SuperErrorSideKick {
    fn description(&self) -> &str {
        "I'm SuperError side kick"
    }
}

fn get_super_error() -> Result<(), SuperError> {
    Err(SuperError { side: SuperErrorSideKick })
}

fn main() {
    match get_super_error() {
        Err(e) => {
            println!("Error: {}", e.description());
            println!("Caused by: {}", e.cause().unwrap());
        }
        _ => println!("No error"),
    }
}Run

Methods

impl Error + 'static
[src]

Returns true if the boxed type is the same as T

Returns some reference to the boxed value if it is of type T, or None if it isn't.

Returns some mutable reference to the boxed value if it is of type T, or None if it isn't.

impl Error + Send + 'static
[src]

Forwards to the method defined on the type Any.

Forwards to the method defined on the type Any.

Forwards to the method defined on the type Any.

impl Error + Send + Sync + 'static
[src]

Forwards to the method defined on the type Any.

Forwards to the method defined on the type Any.

Forwards to the method defined on the type Any.

impl Error
[src]

Attempt to downcast the box to a concrete type.

impl Error + Send
[src]

Attempt to downcast the box to a concrete type.

impl Error + Send + Sync
[src]

Attempt to downcast the box to a concrete type.

Implementations on Foreign Types

impl Error for AllocErr
[src]

impl Error for LayoutErr
[src]

impl Error for CannotReallocInPlace
[src]

impl Error for TryFromSliceError
[src]

Implementors