How to use an Error with a generic as the source of another Error?

[yanshay]

I'm developing in no_std on an embedded device and trying to use Snafu.

With @shepmaster assistance (#493) I managed to get one module working (with DebugWrap).
But I couldn't get the module using that Error to create its own Error with the first one as source.

At high level I want to develop a simple csv-db using sdcard.
Below is the code I ended up with for the first module (the SDCard) - which honestly, I don't fully understand, but its working.
The SDCard module uses an underlying module who's error is generic over the Error of block device which is generic over Spi Device (I hope I got it right)

pub struct DebugWrap<E>(E);

impl<E: core::fmt::Debug> core::error::Error for DebugWrap<E> {}

impl<E: core::fmt::Debug> core::fmt::Debug for DebugWrap<E> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        self.0.fmt(f)
    }
}

impl<E: core::fmt::Debug> core::fmt::Display for DebugWrap<E> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Debug::fmt(&self.0, f)
    }
}


#[derive(Snafu, Debug)]
pub enum Error<E>
where
    E: core::fmt::Debug + 'static,
{
    #[snafu(display("Failed to open volume"))]
    OpenVolume {
        #[snafu(source(from(embedded_sdmmc::asynchronous::Error<E>, DebugWrap)))]
        source: DebugWrap<embedded_sdmmc::asynchronous::Error<E>>,
    },
... 
}

pub type SdCardError<SPI> = <SdCard<SPI, embassy_time::Delay> as BlockDevice>::Error;
pub type SDCardStoreError<SPI> = Error<SdCardError<SPI>>;

impl<SPI: SpiDevice, const MAX_DIRS: usize, const MAX_FILES: usize>
    SDCardStore<SPI, MAX_DIRS, MAX_FILES>
{
pub async fn new(spi: SPI) -> Result<Self, SDCardStoreError<SPI>> {
...

        let volume0 = volume_mgr
            .open_volume(embedded_sdmmc::asynchronous::VolumeIdx(0))
            .await
            .context(OpenVolumeSnafu)?  // <-- use of snafu
            .to_raw_volume();

...

}

With that, now I want to implement my CsvDb which will have as source the SDCardStoreError, but bottom line all my trials failed.

My understanding is that now my SDCardStoreError implements the Error trait because it is generated by Snafu.

So I tried:

#[derive(Snafu, Debug)]
pub enum CsvDbError <SPI: SpiDevice> 
where 
{
    SomeError {
        source: SDCardStoreError<SPI>
    },
}


impl<T, SPI: SpiDevice, const MAX_DIRS: usize, const MAX_FILES: usize>
    CsvDb<T, SPI, MAX_DIRS, MAX_FILES>
where
    T: CsvDbId + Serialize + DeserializeOwned + PartialEq + core::fmt::Debug,
{
    pub async fn new(
        sdcard: Rc<Mutex<CriticalSectionRawMutex, SDCardStore<SPI, MAX_DIRS, MAX_FILES>>>,
        db_name: &str,
        min_record_width: usize,
        min_capacity: usize,
    ) -> Result<Self, CsvDbError<SPI>> {

...


        let dbm_str = sdcard.read_create_str(&dbm_file_name).await.context(SomeSnafu)?;

...

}

And on the context usage the compiler throws an error:

error[E0277]: `SPI` doesn't implement `core::fmt::Debug`
   --> src/csvdb.rs:131:76
    |
131 |         let dbm_str = sdcard.read_create_str(&dbm_file_name).await.context(SomeSnafu)?;
    |                                                                    ------- ^^^^^^^^^ `SPI` cannot be formatted using `{:?}` because it doesn't implement `core::fmt::Debug`
    |                                                                    |
    |                                                                    required by a bound introduced by this call
    |
note: required for `CsvDbError<SPI>` to implement `core::fmt::Debug`

Probably because the compiler doen't know that SPI will not need to be formatted, only it's Error will need to, but it doen't know it here.

I tried all kinds of other options but just couldn't get it to work the way I wanted to.

Maybe too mainy constraints driven by no_std and patterns there, but before I turn to String based errors, I post here the question how can I make it work?

[yanshay]

I think I solved it, don't really understand it completely, but it seems to work:

In the SDCard module I defined:

pub type SDCardStoreErrorType = Error<embedded_sdmmc::asynchronous::SdCardError>;

that's in addition to what I already had:

pub type SdCardError<SPI> = <SdCard<SPI, embassy_time::Delay> as BlockDevice>::Error;
pub type SDCardStoreError<SPI> = Error<SdCardError<SPI>>;

In the CsvDb I used the error:

#[derive(Snafu, Debug)]
pub enum CsvDbError
{
    #[snafu(display("Failed to open volume"))]
    Store {
        source: SDCardStoreErrorType,
    },
}

And now context seem to work and I can match against the errors hierarchically down all the way.
I don't understand how this exactly work, but it seems to work.
While source here doesn't show any relation to the SDCardStoreError, it does allow accessing that enum.
Pretty confusing.

[shepmaster]

I can't directly help you because the original code you provided is not a minimal reproducible example. There are about 20 errors unrelated to your question, such as undefined crates / modules / types.

The general answer is that you don't want to return a generic error because that generic has to propagate all the way up the call stack. Usually you want to provide a concrete type for the generic parameter:

use core::fmt;
use snafu::prelude::*;

struct DebugWrap<E>(E);

impl<E: fmt::Debug> core::error::Error for DebugWrap<E> {}

impl<E: fmt::Debug> fmt::Debug for DebugWrap<E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl<E: fmt::Debug> fmt::Display for DebugWrap<E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, f)
    }
}

#[derive(Debug)]
struct LibraryError<E>(E);

#[derive(Snafu, Debug)]
enum Error {
    #[snafu(display("Failed to open volume"))]
    OpenVolume {
        #[snafu(source(from(LibraryError<String>, DebugWrap)))]
        source: DebugWrap<LibraryError<String>>,
    },
}

fn makes_error() -> Result<(), LibraryError<String>> {
    Ok(())
}

fn uses_error() -> Result<(), Error> {
    makes_error().context(OpenVolumeSnafu)
}

Here, LibraryError is a generic type (as is DebugWrap), but the function that returns the LibraryError specifically returns a String as the generic parameter. That's the type you put in your error enum.