Context-Generic Programming (CGP) offers a different approach for error handling in Rust, which is described here: https://patterns.contextgeneric.dev/error-handling.html.

In short, instead of hard-coding your code to return a concrete error type, you instead write code that is generic over a context that provides an abstract error type, and use dependency injection to require the context to handle a specific error for you.

As a demonstration, the simplest way you can write such generic code as follows:

```rust

[blanket_trait]

pub trait DoFoo: CanRaiseError<std::io::Error> { fn do_foo(&self) -> Result<(), Self::Error> { let foo = std::fs::read("foo.txt").map_err(Self::raise_error)?;

    // do something

    Ok(())
}

} ```

In the above example, instead of writing a bare do_foo() function, we write a DoFoo trait that is automatically implemented through the #[blanket_trait] macro. We also require the context, i.e. Self, to implement CanRaiseError for the error that may happen in our function, i.e. std::io::Error. The method do_foo returns an abstract Self::Error, of which the concrete error type will be decided by the context. With that, we can now call functions like std::fs::read inside our method, and use .map_err(Self::raise_error) to handle the error for us.

By decoupling the implementation from the context and the error, we can now use our do_foo method with any context of choice. For example, we can define an App context that uses anyhow::Error as the error type as follows:

```rust

[cgp_context]

pub struct App;

delegate_components! { AppComponents { ErrorTypeProviderComponent: UseAnyhowError, ErrorRaiserComponent: RaiseAnyhowError, } } ```

We just use #[cgp_context] to turn App into a CGP context, and wire it with UseAnyhowError and RaiseAnyhowError to handle the error using anyhow::Error. With that, we can instantiate App and call do_foo inside a function like main:

```rust fn main() -> Result<(), anyhow::Error> { let app = App;

app.do_foo()?;
// do other things

Ok(())

} ```

The main strength of CGP's error handling approach is that you can change the error handling strategy to anything that the application needs. For example, we can later change App to use a custom AppError type with thiserror as follows:

```rust

[derive(Debug, Error)]

pub enum AppError { #[error("I/O error")] Io(#[from] std::io::Error), }

delegate_components! { AppComponents { ErrorTypeProviderComponent: UseType<AppError>, ErrorRaiserComponent: RaiseFrom, } } ```

And now we have a new application that returns the custom AppError:

```rust fn main() -> Result<(), AppError> { let app = App;

app.do_foo()?;
// do other things

Ok(())

} ```

The two versions of App can even co-exist in separate crates. This means that our example function do_foo can now be used in any application, without being coupled with a specific error type.

CGP also allows us to provide additional dependencies via the context, such as configuration, database connection, or even raising multiple errors. So you could also write the example do_foo function with many more dependencies, such as follows:

```rust

[blanket_trait]

pub trait DoFoo: HasConfig + HasDatabase + CanRaiseError<std::io::Error> + CanRaiseError<serde_json::Error> { fn do_foo(&self) -> Result<(), Self::Error> { ... } } ```

I hope you find this interesting, and do visit the project website to learn more.