errgoGenerate enum error variants inline.
A slightly type-safer take on [anyhow], where each ad-hoc error is handleable by the caller. Designed to play nice with other crates like [strum] or [thiserror].
This crate was written to aid wrapping C APIs - transforming e.g error codes to handleable messages.
It shouldn't really be used for library api entry points - a well-considered top-level error type is likely to be both more readable and forward compatible.
Consider reading Study of std::io::Error or simply making all generated structs pub(crate).
```rust use errgo::errgo;
fn shaveyaks(
numyaks: usize,
emptybuckets: usize,
numrazors: usize,
) -> Result<(), ShaveYaksError> {
if numrazors == 0 {
return Err(err!(NotEnoughRazors));
}
if numyaks > emptybuckets {
return Err(err!(NotEnoughBuckets {
got: usize = emptybuckets,
required: usize = num_yaks,
}));
}
Ok(())
}
Under the hood, a struct like this is generated:
rust
enum ShaveYaksError { // name and visibility are taken from function return type and visibility
NotEnoughRazors,
NotEnoughBuckets {
got: usize,
required: usize,
}
}
``
Note that the struct definition is placed just above the function body, meaning that you can't use [errgo] on functions inimpl` blocks - you'll have to move the function body to an outer scope, and call it in the impl block.
Importantly, you can derive on the generated struct, and passthrough attributes, allowing you to use crates like [thiserror] or [strum].
See the [errgo] documentation for other arguments accepted by the macro.
```rust
fn shaveyaks( numyaks: usize, emptybuckets: usize, numrazors: usize, ) -> Result<(), ShaveYaksError> { if numrazors == 0 { return Err(err!( #[error("not enough razors!")] NotEnoughRazors )); } if numyaks > emptybuckets { return Err(err!( #[error("not enough buckets - needed {required}")] NotEnoughBuckets { got: usize = emptybuckets, required: usize = num_yaks, } )); } Ok(()) } ```
Which generates the following: ```rust
enum ShaveYaksError {
#[error("not enough razors!")]
NotEnoughRazors,
#[error("not enough buckets - needed {required}")]
NotEnoughBuckets {
got: usize,
required: usize,
}
}
``
Anderr!` macro invocations are replaced with struct instantiations - no matter where they are in the function body!
If you need to reuse the same variant within a function, just use the normal construction syntax: ```rust
fn foo() -> Result<(), FooError> { fallibleop().maperr(|e| err!(IoError(io::Error = e))); Err(FooError::IoError(todo!())) } ```