Trait std::error::Error

pub trait Error: Debug + Display {
    fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
    fn backtrace(&self) -> Option<&Backtrace> { ... }
    fn description(&self) -> &str { ... }
    fn cause(&self) -> Option<&dyn 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 source method is generally used when errors cross "abstraction boundaries". If one module must report an error that is caused by an error from a lower-level module, it can allow access to that error via the source method. This makes it possible for the high-level module to provide its own errors while also revealing some of the implementation for debugging via source chains.

Provided methods

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 source(&self) -> Option<&(dyn Error + 'static)> {
        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 get_super_error() -> Result<(), SuperError> {
    Err(SuperError { side: SuperErrorSideKick })
}

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

if let Err(e) = "xc".parse::<u32>() {
    // Print `e` itself, no need for description().
    eprintln!("Error: {}", e);
}

Implementations

impl dyn Error + 'static[src]

pub fn is<T: Error + 'static>(&self) -> bool[src]1.3.0

pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T>[src]1.3.0

pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T>[src]1.3.0

impl dyn Error + Send + 'static[src]

pub fn is<T: Error + 'static>(&self) -> bool[src]1.3.0

pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T>[src]1.3.0

pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T>[src]1.3.0

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

pub fn is<T: Error + 'static>(&self) -> bool[src]1.3.0

pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T>[src]1.3.0

pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T>[src]1.3.0

impl dyn Error[src]

pub fn downcast<T: Error + 'static>(
    self: Box<Self>
) -> Result<Box<T>, Box<dyn Error>>[src]1.3.0

pub fn chain(&self) -> Chain<'_>ⓘ

Notable traits for Chain<'a>

impl<'a> Iterator for Chain<'a>
    type Item = &'a (dyn Error + 'static);

[src]

#![feature(error_iter)]
use std::error::Error;
use std::fmt;

#[derive(Debug)]
struct A;

#[derive(Debug)]
struct B(Option<Box<dyn Error + 'static>>);

impl fmt::Display for A {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "A")
    }
}

impl fmt::Display for B {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "B")
    }
}

impl Error for A {}

impl Error for B {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        self.0.as_ref().map(|e| e.as_ref())
    }
}

let b = B(Some(Box::new(A)));

// let err : Box<Error> = b.into(); // or
let err = &b as &(dyn Error);

let mut iter = err.chain();

assert_eq!("B".to_string(), iter.next().unwrap().to_string());
assert_eq!("A".to_string(), iter.next().unwrap().to_string());
assert!(iter.next().is_none());
assert!(iter.next().is_none());

impl dyn Error + Send[src]

pub fn downcast<T: Error + 'static>(
    self: Box<Self>
) -> Result<Box<T>, Box<dyn Error + Send>>[src]1.3.0

impl dyn Error + Send + Sync[src]

pub fn downcast<T: Error + 'static>(
    self: Box<Self>
) -> Result<Box<T>, Box<Self>>[src]1.3.0

Implementors