为什么这些错误不会自动转换为我的自定义错误，即使它们同时实现了 std::error::Error 特征？

Question

Reproduction project (single main.rs file): https://github.com/frederikhors/iss-custom-err .

I'm trying to create a custom error for my app:

pub struct AppError {
    message: String,
    error: anyhow::Error, // In the future I would also avoid anyhow
}

I'm trying to use it in my code but as you can see I'm getting the below compiler errors, why?

Isn't my AppError implementing the trait std::error::Error correctly?

I would expect an auto conversion from hyper error to AppError being both error:Error traits, am I wrong?

error[E0277]: `?` couldn't convert the error to `AppError`
  --> src\main.rs:20:44
   |
20 |                     .body(Body::from(body))?;
   |                                            ^ the trait `From<hyper::http::Error>` is not implemented for `AppError`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: the following other types implement trait `FromResidual<R>`:
             <Result<T, F> as FromResidual<Result<Infallible, E>>>
             <Result<T, F> as FromResidual<Yeet<E>>>
   = note: required because of the requirements on the impl of `FromResidual<Result<Infallible, hyper::http::Error>>` for `Result<(), AppError>`

error[E0277]: `?` couldn't convert the error to `AppError`
  --> src\main.rs:24:19
   |
24 |             .await?;
   |                   ^ the trait `From<hyper::Error>` is not implemented for `AppError`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: the following other types implement trait `FromResidual<R>`:
             <Result<T, F> as FromResidual<Result<Infallible, E>>>
             <Result<T, F> as FromResidual<Yeet<E>>>
   = note: required because of the requirements on the impl of `FromResidual<Result<Infallible, hyper::Error>>` for `Result<(), AppError>`

For more information about this error, try `rustc --explain E0277`.

Answer 1

I would expect an auto conversion from hyper error to AppError being both error:Error traits, am I wrong?

Yes. Error is a usage trait, it's like IntoIterator : both Vec and HashMap implement it, but that doesn't mean you can convert an arbitrary Vec to a HashMap .

Let alone that Rust will do it for you: Rust generally favors intentionality, it avoids large multi-use concepts. So all error tells you is that you can display the type, and may be able to get its source . It says nothing about conversion, except for conversion to a Box<dyn Error> (because Error is object-safe).

So as the compiler error tells you , if you want Rust (and specifically ? ) to perform the conversion, you need to implement the From trait .

Note: libraries like thiserror or snafu provide tooling to more easily create bespoke error types, and conversions from existing error types.

Answer 2

On discord a kind user helped me understand.

What I need is a generic impl :

impl<T: error::Error + Send + Sync + 'static> From<T> for AppError {
    fn from(e: T) -> Self {
        Self { message: e.to_string(), error: anyhow::Error::new(e) }
    }
}

That's it!