Trait Error

1.0.0 · Source

pub trait Error: Debug + Display {
    // Provided methods
    fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
    fn description(&self) -> &str { ... }
    fn cause(&self) -> Option<&dyn Error> { ... }
    fn provide<'a>(&'a self, request: &mut Request<'a>) { ... }
}

Expand description

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. Error messages are typically concise lowercase sentences without trailing punctuation:

let err = "NaN".parse::<u32>().unwrap_err();
assert_eq!(err.to_string(), "invalid digit found in string");

§Error source

Errors may provide cause 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.

In error types that wrap an underlying error, the underlying error should be either returned by the outer error’s Error::source(), or rendered by the outer error’s Display implementation, but not both.

§Example

Implementing the Error trait only requires that Debug and Display are implemented too.

use std::error::Error;
use std::fmt;
use std::path::PathBuf;

#[derive(Debug)]
struct ReadConfigError {
    path: PathBuf
}

impl fmt::Display for ReadConfigError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let path = self.path.display();
        write!(f, "unable to read configuration at {path}")
    }
}

impl Error for ReadConfigError {}

Provided Methods§

1.30.0 · Source

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

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

§Examples

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

#[derive(Debug)]
struct SuperError {
    source: 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.source)
    }
}

#[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 { source: SuperErrorSideKick })
}

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

1.0.0 · Source

fn description(&self) -> &str

👎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}");
}

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>(&'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.

Used in conjunction with Request::provide_value and Request::provide_ref to extract references to member variables from dyn Error trait objects.

§Example

#![feature(error_generic_member_access)]
use core::fmt;
use core::error::{request_ref, Request};

#[derive(Debug)]
enum MyLittleTeaPot {
    Empty,
}

#[derive(Debug)]
struct MyBacktrace {
    // ...
}

impl MyBacktrace {
    fn new() -> MyBacktrace {
        // ...
    }
}

#[derive(Debug)]
struct Error {
    backtrace: MyBacktrace,
}

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

impl std::error::Error for Error {
    fn provide<'a>(&'a self, request: &mut Request<'a>) {
        request
            .provide_ref::<MyBacktrace>(&self.backtrace);
    }
}

fn main() {
    let backtrace = MyBacktrace::new();
    let error = Error { backtrace };
    let dyn_error = &error as &dyn std::error::Error;
    let backtrace_ref = request_ref::<MyBacktrace>(dyn_error).unwrap();

    assert!(core::ptr::eq(&error.backtrace, backtrace_ref));
    assert!(request_ref::<MyLittleTeaPot>(dyn_error).is_none());
}

Trait Error Copy item path

§Error source

§Example

Provided Methods§

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

§Examples

fn description(&self) -> &str

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

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

§Example

Implementations§

impl dyn Error

pub fn is<T>(&self) -> boolwhere T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Error + 'static,

impl dyn Error + Send

pub fn is<T>(&self) -> boolwhere T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Error + 'static,

impl dyn Error + Sync + Send

pub fn is<T>(&self) -> boolwhere T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>where T: Error + 'static,

impl dyn Error

pub fn sources(&self) -> Source<'_> ⓘ

§Examples

impl dyn Error

pub fn downcast<T>(self: Box<dyn Error>) -> Result<Box<T>, Box<dyn Error>>where T: Error + 'static,

impl dyn Error + Send

pub fn downcast<T>( self: Box<dyn Error + Send>, ) -> Result<Box<T>, Box<dyn Error + Send>>where T: Error + 'static,

impl dyn Error + Sync + Send

pub fn downcast<T>( self: Box<dyn Error + Sync + Send>, ) -> Result<Box<T>, Box<dyn Error + Sync + Send>>where T: Error + 'static,

Trait Implementations§

impl<'a> From<&str> for Box<dyn Error + 'a>

fn from(err: &str) -> Box<dyn Error + 'a>

§Examples

impl<'a> From<&str> for Box<dyn Error + Sync + Send + 'a>

fn from(err: &str) -> Box<dyn Error + Sync + Send + 'a>

§Examples

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + 'a>

fn from(err: Cow<'b, str>) -> Box<dyn Error + 'a>

§Examples

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Sync + Send + 'a>

fn from(err: Cow<'b, str>) -> Box<dyn Error + Sync + Send + 'a>

§Examples

impl<'a, E> From<E> for Box<dyn Error + 'a>where E: Error + 'a,

fn from(err: E) -> Box<dyn Error + 'a>

§Examples

impl<'a, E> From<E> for Box<dyn Error + Sync + Send + 'a>where E: Error + Send + Sync + 'a,

fn from(err: E) -> Box<dyn Error + Sync + Send + 'a>

§Examples

impl<'a> From<String> for Box<dyn Error + 'a>

fn from(str_err: String) -> Box<dyn Error + 'a>

§Examples

impl<'a> From<String> for Box<dyn Error + Sync + Send + 'a>

fn from(err: String) -> Box<dyn Error + Sync + Send + 'a>

§Examples

impl Value for dyn Error

fn record(&self, key: &Field, visitor: &mut dyn Visit)

impl Value for dyn Error + Send

fn record(&self, key: &Field, visitor: &mut dyn Visit)

impl Value for dyn Error + Sync + Send

fn record(&self, key: &Field, visitor: &mut dyn Visit)

impl Value for dyn Error + Sync

fn record(&self, key: &Field, visitor: &mut dyn Visit)

Implementors§

impl !Error for &str

impl Error for HeaderParsingError

impl Error for BaseInterfaceError

impl Error for HTTPError

impl Error for SerialError

impl Error for TCPError

impl Error for WebRTCError

impl Error for WebSocketError

impl Error for WebSocketServerError

impl Error for DeserializationError

impl Error for SerializationError

impl Error for Infallible

impl Error for VarError

impl Error for FromBytesWithNulError

Trait Error

pub fn is<T>(&self) -> bool
where T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Error + 'static,

pub fn is<T>(&self) -> bool
where T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Error + 'static,

pub fn is<T>(&self) -> bool
where T: Error + 'static,

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: Error + 'static,

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: Error + 'static,

pub fn downcast<T>(self: Box<dyn Error>) -> Result<Box<T>, Box<dyn Error>>
where T: Error + 'static,

pub fn downcast<T>( self: Box<dyn Error + Send>, ) -> Result<Box<T>, Box<dyn Error + Send>>
where T: Error + 'static,

pub fn downcast<T>( self: Box<dyn Error + Sync + Send>, ) -> Result<Box<T>, Box<dyn Error + Sync + Send>>
where T: Error + 'static,

impl<'a, E> From<E> for Box<dyn Error + 'a>
where E: Error + 'a,

impl<'a, E> From<E> for Box<dyn Error + Sync + Send + 'a>
where E: Error + Send + Sync + 'a,