error-stack: How to implicitly wrap errors?

[SUPERCILEX]

#[derive(Error, Debug)]
pub enum CliError {
    #[error("{0}")]
    Wrapped(clipboard_history_core::Error),
    ...
}

impl From<clipboard_history_core::Error> for CliError {
    fn from(value: clipboard_history_core::Error) -> Self {
        CliError::Wrapped(value)
    }
}

But the problem is that if I have a function return Result<T, clipboard_history_core::Error>, then I can't implicitly convert it:

34 | fn main() -> error_stack::Result<(), CliError> {
   |              --------------------------------- expected `error_stack::Report<CliError>` because of this
35 |     let mut data_dir = data_dir();
36 |     fs::create_dir_all(&data_dir)
   |     ----------------------------- this can't be annotated with `?` because it has type `Result<_, std::io::Error>`
37 |         .map_io_err(|| format!("Failed to create data directory: {data_dir:?}"))?;
   |          -----------------------------------------------------------------------^ the trait `From<clipboard_history_core::Error>` is not implemented for `error_stack::Report<CliError>`
   |          |
   |          this can't be annotated with `?` because it has type `Result<_, clipboard_history_core::Error>`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: the trait `From<CliError>` is implemented for `error_stack::Report<CliError>`
   = help: for that trait implementation, expected `CliError`, found `clipboard_history_core::Error`
   = note: required for `Result<(), error_stack::Report<CliError>>` to implement `FromResidual<Result<Infallible, clipboard_history_core::Error>>`

Of course I can just use .map_err(CliError::from) but that's kind of annoying. Is there any way around it?

[TimDiekmann]

error-stack does only provide converting between MyError and Report<MyError>. This is a design decision to avoid implicit conversions which should be handled by the user.

I don't really understand what you're trying to achieve with your provided example. The code snippet does not use error-stack, you're using thiserror (I guess) only here. (btw, #[from] is easier that implementing it manually). If you want to convert your error to an error-stack Report you either need the same type (e.g. MyError. to Report<MyError> which enables the usage of ? as From<X> for Report<X> is provided) or you have to call .change_context() on your Result.

[SUPERCILEX]

Thanks for the #[from] tip!

I'm using error_stack in the error message I showed: the gist is that I'm writing a library which can't use error stack, but then I use error stack in a CLI so I'm trying to bridge between the library error type and the CLI error type. It should like map_err is indeed the way to go?

[TimDiekmann]

Yes, the best option here is using .map_err(CliError::from) as the CliError does contain the full error.

If you're willing to change your enum CliError it's possible to let error-stack handle this properly, e.g.:

#[derive(Error, Debug)]
pub enum CliError {
    #[error("The CLI encountered an error ... more context info ... ")]
    ClientHistory { /* more context on your error */ },
    ...
}

fn client_history() -> Result<_, client_history_core::Error> { ... }

fn my_function() -> Result<_, Report<CliError>> {
    client_history().change_context(CliError::ClientHistory { /* ... */ })?;
    // or
    client_history().change_context_lazy(|| CliError::ClientHistory { /* ... */ })?;
	...
}

This way you will get a more readable error later as the client error is properly encoded in error-stack and you even have more context available.

[SUPERCILEX]

Oh I see, thanks!