With the recent proliferation of error-handling crates, it has become clear that the situation around the lack of a core::error::Error is really suboptimal. In SNAFU, no_std support is being introduced through a whole new Error trait just for no_std - which could lead to similar problems that failure had by becoming incompatible with the ecosystem.
Ideally, the Error trait would show up in core, but due to coherence concerns and std-dependent features being added to std::error::Error, a resolution is unlikely to happen soon. As such, I propose making a new crate, core-error - exposing our own version of the Error trait. The goal of this crate is twofolds:
Provide a common trait for various error handling crates (Failure, SNAFU, Fehler, Anyhow, error_chain, and any other)
Allow no_std libraries that don't want to depend on a specific error handling crate to still expose errors that can interoperate with those libraries.
Such a crate would work like this:
With the std feature, it just re-export std::error::*
With no-default-features, it exposes an Error trait similar to the one in std but without backtraces, and without the std/alloc-only impls.
Rustc version auto-detection is used to figure which errors to implement the trait on.
The alloc feature enables downcasting, in addition to supporting alloc errors
The crate would compile on all versions from 1.0.0 to the latest stable version.
The trait will be compatible with std's Error trait, and if libcore gains an Error trait in the future, it should be compatible with it too.
Once the crate reaches 1.0.0, I'll consider it ready for integration in the various error crates and will follow the same stability guarantee Rust does: No breaking changes ever.
With the recent proliferation of error-handling crates, it has become clear that the situation around the lack of a
core::error::Erroris really suboptimal. In SNAFU,no_stdsupport is being introduced through a whole newErrortrait just forno_std- which could lead to similar problems thatfailurehad by becoming incompatible with the ecosystem.Ideally, the
Errortrait would show up in core, but due to coherence concerns and std-dependent features being added tostd::error::Error, a resolution is unlikely to happen soon. As such, I propose making a new crate,core-error- exposing our own version of theErrortrait. The goal of this crate is twofolds:Such a crate would work like this:
std::error::*no-default-features, it exposes anErrortrait similar to the one instdbut without backtraces, and without the std/alloc-only impls.The trait will be compatible with std's
Errortrait, and if libcore gains anErrortrait in the future, it should be compatible with it too.Once the crate reaches 1.0.0, I'll consider it ready for integration in the various error crates and will follow the same stability guarantee Rust does: No breaking changes ever.
Work has already started in https://github.com/core-error/core-error. I'd be interested in hearing feedback on the design.