Trait tract_hir::internal::tract_downcast_rs::__std::error::Error1.0.0[−][src]

pub trait Error: Debug + Display {
    pub fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
    pub fn backtrace(&self) -> Option<&Backtrace> { ... }
    pub fn description(&self) -> &str { ... }
    pub 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:

Error::source() 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 accessing that error via Error::source(). 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

`pub fn source(&self) -> Option<&(dyn Error + 'static)>`1.30.0[src]

The lower-level source 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 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"),
    }
}

`pub fn backtrace(&self) -> Option<&Backtrace>`[src]

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

Returns a stack backtrace, if available, of where this error occurred.

This function allows inspecting the location, in code, of where an error happened. The returned Backtrace contains information about the stack trace of the OS thread of execution of where the error originated from.

Note that not all errors contain a Backtrace. Also note that a Backtrace may actually be empty. For more information consult the Backtrace type itself.

`pub fn description(&self) -> &str`[src]

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

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

`pub fn cause(&self) -> Option<&dyn Error>`[src]

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

Loading content...

Implementations

`impl dyn Error + 'static`[src]

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

Returns true if the boxed type is the same as T

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

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