utils-results

The easiest and most intuitive error handling solution. (no dependencies, about 150 lines pure codes)

Crates.io MIT licensed example workflow

| Docs |

toml [dependencies] utils_results = "3.0.0"

Overview

First, You should make your own an error set. rust err! { BrokenHeader => "broken header." AnotherHeader => "not matched header." FileNotFound => "file not found." EmptyArgument => "empty argument." UnexpectedEof => "unexpected eof." OutOfBounds => "index out of bounds." NotMatched => "btw not matched." } And just errbang! rust errbang!(err::BrokenHeader)

More Examples

```rust fn foo() -> Result { // Our Master Result Type let bar = 2; match bar { 0 => Ok(true), 1 => Ok(false), _ => errbang!(err::NotMatched, "{} is {}", "bar", bar), } }

fn main() -> Result<()> { let isbar_zero = foo()?; Ok(()) } rust errbang!(err::MyError1); errbang!(err::MyError2, "cannot find."); errbang!(err::MyError3, "{} is {}", "bar", 2); ```

errcast

Any type of error can be converted into our Master Error. (non panic unwraping)

\errcast! (\

```rust // example let num_read = errcast!(file.read(&mut buf), err::ReadErr, "this is {} data.", "meta");

```

Also casted error has more information.

rust // example let file = errcast!(fs::File::open("test"), err::MyError, "also io error"); Error: MyError { meta: "[src/main.rs:8] casted error [ fs::File::open(\"test\") ==> Os { code: 2, kind: NotFound, message: \"No such file or directory\" } ] *also io error", message: "this is my error." }

Simply just do this!

rust let file = errcast!(File::open("test"), err::FileOpenError)

or...

rust // master `Result` can take any errors let file = File::open("test")?; But, errcast -> errextract combo is really good choice.

```rust fn exe(path: &str) -> Result { let file = errcast!(File::open("test"), err::FileOpenError); // ..... // ... Ok(num) }

fn main() -> Result<()> { /// non panic unwraping /// and specific error can return /// matching block let num = errextract!(exe(path), err::FileOpenError => 0); /// other errors will go out -> Result

Ok(())

}

```

More idiomatic way to handle io::Error

```rust

io_err! { // io::ErrorKind => err::MyError UnexpectedEof => err::MyError1 Interrupted => err::MyError2 NotFound => err::MyError3 // ... }

Declare matching macro and just handle that.<br> rust

iotoerr!(file.seek(SeekFrom::End(0)))?;

errtoio!(my_seek(0))?;

```

Master Result

  • Please use our Master Result\ResultSend\instead std::result::Result or io::Result etc..
utils-results/lib.rs Definition

```rust /// Master Result pub type Result = result::Result>;

/// Master Result for Send + Sync trait pub type ResultSend = result::Result>;

```

just put this in your project.

```rust pub use utils_results::*;

```

You can also convert any type of Result

| easy way

```rust // to our Master Result resultcast!(handle.join().unwrap())?;

// also can convert master Result to ResultSend resultcastsend!(somemasterresult())?; ```