errgoGenerate enum error types inline.
If you want: - to easy throw errors inline like with [anyhow] - to make your error types handleable in a nice enum like [thiserror]
then this is the crate for you!
```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,
}
}
```
Importantly, you can derive on the generated struct, and passthrough attributes, allowing you to use crates like [thiserror]. ```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!())) } ```