Why doesn't `anyhow::Error` implement `std::error::Error`? about anyhow

[dtolnay]

This is intentional, since that impl would be incoherent with the existing two impls impl From<T> for T and impl<E> From<E> for anyhow::Error where E: std::error::Error + Send + Sync + 'static.

The impl you should write is:

impl<T> FromStr for StrList<T>
where
    T: FromStr,
    anyhow::Error: From<T::Err>,

[Razican]

Cool! that's true, I was able to implement it like that. But I have another situation, using diesel's Error type, that if I want to create one, it only accepts a boxed std::error::Error. How can I achieve that from an anyhow::Error?

[dtolnay]

We provide a conversion to boxed std::error::Error, so .into() would do the trick.
https:​//docs.rs/anyhow/1.0.26/anyhow/struct.Error.html#impl-From<Error>

[Razican]

Thanks! That worked perfectly :) Great job with the lib!!

I'll close this now.

[emilazy]

I personally find it really unfortunate that there's no way to work with anyhow::Errors in a generic context without the extra fuss/overhead of boxing, though I understand trait coherence makes it difficult. Just thought I'd register this as something I was confused enough about to go look in the issue tracker -- I think it could at least use more explicit documenting if nothing else.

[emilazy]

I think a nice way to solve this that would also make the implementation of the conversion into std::error::Error a lot less scary is to just provide a newtype wrapper over anyhow::Error that doesn't have the From conveniences, but does implement Error. Then you could freely convert back and forth according to your needs, and adapt to APIs that expect Error more easily.

edit: it's also pretty hard to work around, because Box<dyn Error> doesn't implement Error either :(

[emilazy]

Trivial proof of concept of what it'd be nice to see in anyhow proper:

struct AsStdError(anyhow::Error);

impl From<anyhow::Error> for AsStdError {
    fn from(err: anyhow::Error) -> Self {
        Self(err)
    }
}

impl fmt::Debug for AsStdError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(fmt)
    }
}

impl fmt::Display for AsStdError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(fmt)
    }
}

impl Error for AsStdError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        self.0.source()
    }

    // requires nightly to implement, which is prohibitive for downstream code
    fn backtrace(&self) -> Option<Backtrace> {
        self.0.backtrace()
    }
}

I think the main thing that would need bikeshedding here is the name.

[dtolnay]

I don't plan to put a wrapper in anyhow because users should use thiserror if they need one.

use thiserror::Error;

#[derive(Error, Debug)]
#[error(transparent)]
pub struct AsStdError(#[from] anyhow::Error);

This expands to what you wrote. Also it has the advantage of being a local type for the purpose of orphan rules and adding inherent methods.

[emilazy]

Oh, that's fair; I'm a happy user of thiserror but didn't realize it would suffice for this case. Thanks!