Trait StdError

pub trait StdError: 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>) { ... }
}

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

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.

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

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"),
    }
}

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

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.

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());
}

Implementations

impl dyn Error

pub fn is<T>(&self) -> bool

where T: Error + 'static,

Returns true if the inner type is the same as T.

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: Error + 'static,

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

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Error + 'static,

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

impl dyn Error + Send

pub fn is<T>(&self) -> bool

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

impl dyn Error + Sync + Send

pub fn is<T>(&self) -> bool

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: Error + 'static,

Forwards to the method defined on the type dyn Error.

impl dyn Error

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

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

Returns an iterator starting with the current error and continuing with recursively calling Error::source.

If you want to omit the current error and only use its sources, use skip(1).

Examples

#![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.sources();

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

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

where T: Error + 'static,

Attempts to downcast the box to a concrete type.

impl dyn Error + Send

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

where T: Error + 'static,

Attempts to downcast the box to a concrete type.

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,

Attempts to downcast the box to a concrete type.

Trait Implementations

impl AsRef<dyn Error> for Report

fn as_ref(&self) -> &(dyn Error + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<dyn Error + Sync + Send> for Report

fn as_ref(&self) -> &(dyn Error + Sync + Send + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Converts a str into a box of dyn Error.

Examples

use std::error::Error;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))

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

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

Converts a str into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))

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

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

Converts a Cow into a box of dyn Error.

Examples

use std::error::Error;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))

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>

Converts a Cow into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))

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

where E: Error + 'a,

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

Converts a type of Error into a box of dyn Error.

Examples

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

#[derive(Debug)]
struct AnError;

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

impl Error for AnError {}

let an_error = AnError;
assert!(0 == size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))

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>

Converts a type of Error + Send + Sync into a box of dyn Error + Send + Sync.

Examples

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

#[derive(Debug)]
struct AnError;

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

impl Error for AnError {}

unsafe impl Send for AnError {}

unsafe impl Sync for AnError {}

let an_error = AnError;
assert!(0 == size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
    size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))

impl From<Report> for Box<dyn Error>

fn from(error: Report) -> Box<dyn Error>

Converts to this type from the input type.

impl From<Report> for Box<dyn Error + Sync + Send>

fn from(error: Report) -> Box<dyn Error + Sync + Send>

Converts to this type from the input type.

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

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

Converts a String into a box of dyn Error.

Examples

use std::error::Error;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(size_of::<Box<dyn Error>>() == size_of_val(&a_boxed_error))

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

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

Converts a String into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    size_of::<Box<dyn Error + Send + Sync>>() == size_of_val(&a_boxed_error))

Implementors

impl !Error for &str

impl Error for StorageValueNameError

impl Error for TemplateTypeError

impl Error for InitStorageDataError

impl Error for RpoDigestError

impl Error for RpxDigestError

impl Error for MerkleError

impl Error for MmrError

impl Error for SmtLeafError

impl Error for SmtProofError

impl Error for RandomCoinError

impl Error for AccountDeltaError

impl Error for AccountError

impl Error for AccountIdError

impl Error for AccountTreeError

impl Error for AssetError

impl Error for AssetVaultError

impl Error for BatchAccountUpdateError

impl Error for FungibleFaucetError

impl Error for NetworkIdError

impl Error for NoteError

impl Error for NullifierTreeError

impl Error for PartialBlockchainError

impl Error for ProposedBatchError

impl Error for ProposedBlockError

impl Error for ProvenBatchError

impl Error for ProvenTransactionError

impl Error for TokenSymbolError

impl Error for TransactionInputError

impl Error for TransactionOutputError

impl Error for TransactionScriptError

impl Error for DeserializationError

impl Error for HexParseError

impl Error for AssemblyError

impl Error for MastForestError

impl Error for MietteError

impl Error for Infallible

impl Error for FromBytesWithNulError

impl Error for core::slice::GetDisjointMutError

impl Error for VarError

impl Error for std::fs::TryLockError

impl Error for RecvTimeoutError

impl Error for TryRecvError

impl Error for indexmap::GetDisjointMutError

impl Error for ExecutionOptionsError

impl Error for RowIndexError

impl Error for CaseKindError

impl Error for IdentError

impl Error for LibraryError

impl Error for PathError

impl Error for VersionError

impl Error for miden_core::errors::InputError

impl Error for KernelError

impl Error for OutputError

impl Error for MemoryError

impl Error for ExecutionError

impl Error for Ext2InttError

impl Error for VerificationError

impl Error for BernoulliError

impl Error for rand::distr::uniform::Error

impl Error for rand::distr::weighted::Error

impl Error for toml_edit::ser::Error

impl Error for AssertionError

impl Error for MerkleTreeError

impl Error for winter_fri::errors::VerifierError

impl Error for ProverError

impl Error for winter_verifier::errors::VerifierError

impl Error for !

impl Error for RelatedError

impl Error for RelatedLabel

impl Error for Box<dyn Diagnostic + Send>

impl Error for Box<dyn Diagnostic + Sync + Send>

impl Error for Box<dyn Diagnostic>

impl Error for UnorderedKeyError

impl Error for alloc::collections::TryReserveError

impl Error for FromVecWithNulError

impl Error for IntoStringError

impl Error for NulError

impl Error for FromUtf8Error

impl Error for FromUtf16Error

impl Error for LayoutError

impl Error for AllocError

impl Error for TryFromSliceError

impl Error for BorrowError

impl Error for BorrowMutError

impl Error for CharTryFromError

impl Error for ParseCharError

impl Error for DecodeUtf16Error

impl Error for TryFromCharError

impl Error for FromBytesUntilNulError

impl Error for core::fmt::Error

impl Error for AddrParseError

impl Error for ParseFloatError

impl Error for ParseIntError

impl Error for TryFromIntError

impl Error for ParseBoolError

impl Error for Utf8Error

impl Error for TryFromFloatSecsError

impl Error for JoinPathsError

impl Error for WriterPanicked

impl Error for std::io::error::Error

impl Error for NormalizeError

impl Error for StripPrefixError

impl Error for ExitStatusError

impl Error for RecvError

impl Error for AccessError

impl Error for SystemTimeError

impl Error for BuildError

impl Error for MatchError

impl Error for PatternIDError

impl Error for StateIDError

impl Error for HexError

impl Error for InvalidLength

impl Error for InvalidBufferSize

impl Error for InvalidOutputSize

impl Error for getrandom::error::Error

impl Error for indexmap::TryReserveError

impl Error for object::read::Error

impl Error for Empty

impl Error for OsError

impl Error for semver::parse::Error

impl Error for serde::de::value::Error

impl Error for OverflowError

impl Error for toml::de::Error

impl Error for toml::ser::Error

impl Error for DatetimeParseError

impl Error for toml_edit::de::Error

impl Error for TomlError

impl Error for InstallError

impl Error for MietteDiagnostic

impl<'a, K, V> Error for alloc::collections::btree::map::entry::OccupiedError<'a, K, V>

where K: Debug + Ord, V: Debug,

impl<'a, K, V> Error for std::collections::hash::map::OccupiedError<'a, K, V>

where K: Debug, V: Debug,

impl<'a, T> Error for &'a T

where T: Error + ?Sized,

impl<A, S, V> Error for ConvertError<A, S, V>

where A: Display + Debug, S: Display + Debug, V: Display + Debug,

impl<E> Error for Box<E>

where E: Error,

impl<I> Error for winnow::error::InputError<I>

where I: Clone + Debug + Display + Sync + Send + 'static,

impl<I, C> Error for TreeError<I, C>

where I: Debug + Display + Sync + Send + 'static, C: Display + Debug,

impl<Src, Dst> Error for AlignmentError<Src, Dst>

where Src: Deref, Dst: KnownLayout + ?Sized,

impl<Src, Dst> Error for SizeError<Src, Dst>

where Src: Deref, Dst: KnownLayout + ?Sized,

impl<Src, Dst> Error for ValidityError<Src, Dst>

where Src: Deref, Dst: KnownLayout + TryFromBytes + ?Sized,

impl<T> Error for SendTimeoutError<T>

impl<T> Error for TrySendError<T>

impl<T> Error for std::sync::poison::TryLockError<T>

impl<T> Error for ThinBox<T>

where T: Error + ?Sized,

impl<T> Error for Arc<T>

where T: Error + ?Sized,

impl<T> Error for SendError<T>

impl<T> Error for PoisonError<T>

impl<W> Error for IntoInnerError<W>

where W: Send + Debug,