Crate utils_results[][src]

Expand description

First, You should make your own an error set.


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!


More Examples

fn foo() -> Result<bool> { // 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 _is_bar_zero = foo()?;
errbang!(err::MyError2, "cannot find.");
errbang!(err::MyError3, "{} is {}", "bar", 2);

| Result

[src/ 40:1] unexpected eof. bar is 2 <err::UnexpectedEof>

unwrapping error input data. also can easily compare them.

fn foo() -> Result<()> {
    // example
    return errbang!(err::Bar, "this is input.");

   errunwrap!(foo(), err::Bar), "this is input."


    1. One result type(anyhow).
    1. All casted errors have their own chaining error’ information(all the previous errors).

if you follow below rules, you can easily debug all your projects.

errbang -> errcast -> errcast -> … -> errcast -> errextract

Quick Overview

use utils_results::*;

err! {
    One => "this error is first one."
    Two => "this error is second one."
    Three => "this error is third one."
    Well => "is this?"

fn aaa() -> Result<usize> {
    return errbang!(err::One, "{}.error bang!", 1);

fn bbb() -> Result<usize> {
    let n = errcast!(aaa(), err::Two, "{}.two <- one.", 2);

fn ccc() -> Result<usize> {
    Ok(errcast!(bbb(), err::Three, "{}.three <- two.", n))

fn main() -> Result<()> {
    let c = errextract!(ccc(), err::Well => 127);
    eprintln!("1/{} is cosmological constant.", c);

| Result

[src/ 11:12] this error is first one. 1.error bang! <err::One> aaa()
[src/ 14:13] this error is second one. 2.two <- one. <err::Two> bbb()
[src/ 18:8] this error is third one. 3.three <- two. <err::Three>

If the matching error be changed,

// Well to Three
let c = errextract!(ccc(), err::Three => 127);

| Result

1/127 is cosmological constant.


Any type of error can be converted into our Master Error.

// example
// <Unwraped Ok> = errcast!(<Any Result>, <Master Err>, <Optional,..>);
let num_read = errcast!( buf), err::ReadErr, "this is {} data.", "meta");

Simply just do this!

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


// Master `Result` can take any errors
let file = File::open("test")?;

// if cfg!(no_std),
let file = io_to_err!(File::open("test"))?;

But, errcast -> errextract combo is always good choice.

fn exe(path: &str) -> Result<usize> {
    let file = errcast!(File::open("test"), err::FileOpenError);
    // .....
    // ...

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<T>


Master Result

  • Please use our Master Result<T> instead std::result::Result or io::Result etc..
  • this is anyhow Result.

utils-results/ Definition
/// Master Result
pub type Result<T> = anyhow::Result<T>;

just put this in your project.

pub use utils_results::*;

You can also convert any type of Result

// to our Master Result


create custom error list

casting Master Error to core::io Error matched by io_err

make some error. floating Err(..)

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

Any type of error can be converted into our Master Error. (and unwraping)
And then panic!

non panic unwraping and specific error can return matching block
other errors will go out -> Result<T>

any type of inside Err() can match this

panic! with Master Error

println! with Master Error

unwrapping error input data.

matching io::Error and Master Error to use casting error macros

casting core::io Error to Master Error matched by io_err

this will convert any result type to Master Result.


Master Result

Type Definitions

Master Result