Collaborate on a "core::Error" crate with snafu, anyhow and other error crates

[roblabla]

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.

Work has already started in https://github.com/core-error/core-error. I'd be interested in hearing feedback on the design.

[withoutboats]

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.

The solution to this problem is to make core, alloc and std a single crate, compiled under different feature flags. This refactor is blocked on the fact that it would be infrastructurally complicated to make the change, but it would be very high value to fixing this and several other problems in std's API. I would really love to see someone driving fixing this problem.

NB that the parts of fehler that rely on the Error trait could only be no_std + alloc compatible, as they depend on access to heap allocation APIs.

[roblabla]

The solution to this problem is to make core, alloc and std a single crate

I agree, and I sort of hope that work on std aware cargo will help towards this goal by simplifying the build system and adding a proper way to build libstd with different features.

Unfortunately, I don’t have enough time nor the required knowledge to drive such an initiative right now. Core-error is a much simpler answer to the specific problem of error handling crates that should be fully forward compatible with a unified libstd future.

the parts of fehler that rely on the Error trait could only be no_std + alloc compatible

That’s expected, and totally acceptable.

[withoutboats]

I'm going to strip everything that depends on the error trait out of this library, because its duplicating basically exactly the functionality of anyhow (if there are any differences I expect they're my deficiencies). I know dtolnay was +1 on working with you on this, so you can cross den Fehler off your list for potentially incompatible libraries.