woe

woe is a (currently nightly-only) Rust crate which provides the following type:

rust enum Result<T, L, F> { Ok(T), LocalErr(L), FatalErr(F), }

This type differentiates between "local errors" which can be handled and "fatal errors" which can't, to enable the error handling pattern described by Tyler Neely (@spacejam) in the blog post "Error Handling in a Correctness-Critical Rust Project". woe::Result is intended to be a more ergonomic alternative to the Result<Result<T, LocalError>, FatalError> type proposed in the post.

The important thing to note is that using the question mark operator on woe::Result causes any FatalError to propagate up, while providing Result<T, LocalError> otherwise, to enable the local code to handle any local errors without propagating them.

Example

```rust use std::ops::Try; use woe::Result::{self, Ok, LocalErr, FatalErr}; use std::result::Result as StdResult;

fn main() { match dothing() { StdResult::Ok(num) => println!("Got a number: {}", num), StdResult::Err(fatalerr) => eprintln!("Fatal error: {:?}", fatal_err), } }

fn dothing() -> StdResult { let result = doanother_thing(5, 5)?;

match result {
    StdResult::Err(local_err) => {
        println!("Local error: {:?}", local_err);
        StdResult::Ok(i64::default())
    }
    StdResult::Ok(num) => StdResult::Ok(num),
}

}

fn doanotherthing(x: i64, y: i64) -> Result { let result = dothirdthing(x, y)?; Result::from_ok(result) }

fn dothirdthing(x: i64, y: i64) -> Result { if x > y { Ok(x) } else if x == y { LocalErr(LocalError::SomeError) } else { FatalErr(FatalError::CatastrophicError) } }

[derive(Debug)]

enum LocalError { SomeError, AnotherError, }

[derive(Debug)]

enum FatalError { BigBadError, CatastrophicError, } ```