Having hard time trying to use Box<dyn std::error::Error + Send + Sync + 'static>

[dpc]

In the docs I often see: #[snafu(source(from(Box<dyn std::error::Error + Send + Sync>, Box))], but that's a metric ton of typing, so was hoping to use a type alias. It mostly works, but sometimes Snafu seems to dislike it. E.g.:

pub type BoxedError = Box<dyn std::error::Error + Send + Sync + 'static>;
pub type BoxedErrorResult<T> = std::result::Result<T, BoxedError>;

pub async fn foo() -> BoxedErrorResult<()> {
    todo!();
}


#[tokio::main]
#[snafu::report]
async fn main() -> BoxedErrorResult<()> {
    foo().await?;
    Ok(())
}

the size for values of type `(dyn snafu::Error + std::marker::Send + std::marker::Sync + 'static)` cannot be known at compilation time

BTW. Would it be possible for snafu to come with some "Boxed error" built-in error, that would just to the right thing? Like Whatever error, but not just stringly-based, but type-erased-error one.

[shepmaster]

Snafu seems to dislike it.

async fn main() -> BoxedErrorResult<()>

snafu::Report (and thus #[snafu::report]) require that the error value implement std::error::Error, but Box<dyn Error> does not implement that trait:

fn is_error<E: std::error::Error>() {}
fn main() { is_error::<Box<dyn std::error::Error>>() }

error[E0277]: the size for values of type `dyn std::error::Error` cannot be known at compilation time
 --> src/main.rs:2:24
  |
2 | fn main() { is_error::<Box<dyn std::error::Error>>() }
  |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `dyn std::error::Error`
  = help: the trait `std::error::Error` is implemented for `Box<E>`
  = note: required for `Box<dyn std::error::Error>` to implement `std::error::Error`
note: required by a bound in `is_error`
 --> src/main.rs:1:16
  |
1 | fn is_error<E: std::error::Error>() {}
  |                ^^^^^^^^^^^^^^^^^ required by this bound in `is_error`

Would it be possible for snafu to come with some "Boxed error" built-in error, that would just to the right thing? Like Whatever error, but not just stringly-based, but type-erased-error one.

I don't understand the distinction that you are making. Can you give an example of how this other type would be used or be implemented, and how Whatever doesn't address that case today?

[dpc]

So this would work if Box<dyn Error> impl-ed Error, but it doesn't?

how Whatever doesn't address that case today

Hmm. I think I was confused about Whatever being strictly a String under the hood error. Now I looked under the hood. I will try to see if I should just use it directly in my code.

Otherwise maybe I can impl my own newtype over Box<dyn Error>. In a way - I use Box<dyn Error> because I do not want to add any context/messages sometimes.