Crate utils_results

First, You should make your own an error set.

Example

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!

errbang!(err::BrokenHeader);

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()?;
    Ok(())
}

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)

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

---

Also casted error has more information.

// 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!

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

or…

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

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

fn exe(path: &str) -> Result<usize> {
    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<T>

    Ok(())
}

---

More idiomatic way to handle io::Error

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

Declare matching macro and just handle that!

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

err_to_io!(my_seek(0))?;

Master Result

• Please use our Master Result<T> and ResultSend<T> instead std::result::Result or io::Result etc..

---

utils-results/lib.rs Definition

/// Master Result
pub type Result<T> = result::Result<T, Box<dyn error::Error>>;

/// Master Result for Send + Sync trait
pub type ResultSend<T> = result::Result<T, Box<dyn error::Error + Send + Sync>>;

---

just put this in your project.

pub use utils_results::*;

You can also convert any type of Result

// to our Master Result
resultcast!(handle.join().unwrap())?;
// also can convert master Result to ResultSend
resultcastsend!(some_master_result())?;

Macros

err

create custom error list

err_to_io

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

errbang

make some error. Master Result::Err()

errbangsend

make some error for thread. Master ResultSend::Err()

errcast

any type of inside Err() can be converted
and Ok() will be unwraped, converted err will be escaped

errextract

matched error returns or excutes, other errors return to outside(escape)
and Ok() will unwrap

errmatch

any type of inside Err() can match this

io_err

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

io_to_err

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

resultcast

this will convert any result type to our Master Result.

resultcastsend

this will convert any result type to our Master ResultSend.

Type Definitions

Result

Master Result

ResultSend

Master Result for Send + Sync trait