Add a typed source getter on struct errors

[RustyNova016]

It would be great to have some sort of .get_source() getter method on struct errors.

This would make it easier to get the source of the error without having to go through down casting Error::source() when the type is statically known

Technically you could just set the source field as public, but you could forget it

[shepmaster]

I don't think that this is something that SNAFU will do.

If you are in the same module (or a child module) as the error, then you don't need to do anything and can directly access the field, even without making it public.

If you are not in the same module as the error, then exposing the source requires making a public API. Expanding the public API of the error is not something that SNAFU wants to do by default, which means that it'd have to be opt-in. At that point, you'd have some attribute like #[snafu(foo)] which (1) isn't shorter than pub and (2) can be forgotten as easily as pub.

If you go the route of a function, you'd also have to make decisions around what the return value is (e.g. &Source, &mut Source, Source) or how many of those variations to include. The naming of the function(s) is also something that people would likely want to customize.

Going beyond the mechanics, there's the question of why exposing the source is a desired or good thing. Exposing your internals means that it's easier to write code that is tangled up with implementation details, which is generally regarded as suboptimal.

With all of that said, I think that requiring the user to add either the pub keyword or a public method isn't undue burden.

[RustyNova016]

It was more of an easier way to get the source when the type is known without having to downcast it. But I can understand if it's outside the scope of the crate

Exposing the source is still useful, as another library could want to dig into the source to match on a specific error (Ex: if request return "Connection reset", retry the query).

[shepmaster]

I'm not saying that poking directly at the source is never useful, only that it's rarely useful. The rarity means that it shouldn't be the default. Taking the configuration knobs into account (enabled or not, the name of the function, the specific return type, etc.) means that the macro can provide little value over a manual implementation.

For example:

// If the macro provided it
#[derive(Debug, Snafu)]
#[snafu(typed_source(get_source, &self))]
struct Error(std::io::Error);

// If the user provided it
#[derive(Debug, Snafu)]
struct Error(std::io::Error);

impl Error {
    fn get_source(&self) -> &std::io::Error { &self.0 }
}

as another library could want to dig into the source to match on a specific error

Crossing library boundaries is exactly the reason that exposing internal implementation details should not be the default. For example, say you have something like

// This is my_library version 1.0.0
use networking_library; // version 1.0.0

pub enum Error {
    Connection { source: networking_library::Error }
}

If you

• upgrade to networking_library version 2.0
• replace networking_library with better_library
• change your error to split Connection into multiple detailed errors

Then you need to release my_library 2.0 because you've changed your public API.

Instead, I usually recommend enhancing the error to expose details in a very controlled way. This is also why SNAFU offers opaque errors. Continuing the example...

// This is my_library version 1.0.0
use networking_library; // version 1.0.0

enum InnerError {
    Connection { source: networking_library::Error }
}

struct Error(InnerError);

impl Error {
    // Can you directly answer the question for clients? If so, do that to avoid making all the clients repeat the logic.
    fn is_retryable(&self) -> bool { todo!() }

    // Maybe return an enumeration of category of error
    fn kind(&self) -> ErrorKind { todo!() }

    // Maybe you *need* to expose a concrete error type, so just do that single one.
    fn network_error(&self) -> Option<&networking_library::Error> { todo!() }
}

enum ErrorKind {
    Network { retryable: bool }

    Disk { retryable: bool }
}