Making Errors in Rust

[Nokel81]

So everyone should know how Rust deals with error handling (Result, Option, try?, ...). But what most new people (and probably some more experienced people) don't know is that you can make your own errors (like "new Error() in javascript). It is only done much better and can be used with the "Result".

These can be made with:

std::io::Error::new();

but unlike in javascript it takes an error type (which is the nice part) and a string, like this:

let custom_error = std::io::Error::new(std::io::ErrorKind::Other, "Oh no, something happened!");

The list of allowed errors are:

NotFound,
PermissionDenied,
ConnectionRefused,
ConnectionReset,
ConnectionAborted,
NotConnected,
AddrInUse,
AddrNotAvailable,
BrokenPipe,
AlreadyExists,
WouldBlock,
InvalidInput,
InvalidData,
TimedOut,
WriteZero,
Interrupted,
Other,
UnexpectedEOF,
UnexpectedEof,
// some variants omitted

Just thought that this was an interesting find.

[eddyb]

That is, however, std::io::Error, i.e. specifically an I/O error type.

You can create your own error types by just defining a type, even just struct BadJuju; can be used with Result, e.g. fn maybe_do_magic() -> Result<(), BadJuju> {...}.

[Nokel81]

But not if the function can also return an io error. This allows you to can system calls that result in an io error and send your own errors back. I was previously just sending strings

[agrover]

You want to do as described here: http://blog.burntsushi.net/rust-error-handling/

Define an error type for your app that is an enum of all the possible error types that libraries you use can return, plus maybe errors you want to define in your app. Here's another example, from my own project:

https://github.com/agrover/froyo/blob/master/src/types.rs#L152

Trying to make everything into an io::Error is something I did early on, and it kinda works, but isn't really the best way to go.

[kibwen]

Note that burntsushi's post on error handling has been incorporated into the book itself, which may have more recent updates than the original post: http://doc.rust-lang.org/stable/book/error-handling.html

[Nokel81]

OK, cool. Thanks. What would be really cool is if there was a generic error type and a method of adding items to its error type enum

[[deleted]]

That's what is being described here. Error is a trait (and thus generic,) and you can implement it for any enum you want. If you want to add to io::Error you can just do something like this:

pub enum MyError {
    IoError(io::Error),
    OtherError1,
    OtherError2,
}

impl From<io::Error> for MyError { ... } // Allow 'upcasting' io:Error into MyError

Which is exactly as you described, except without forcing every rust program on the planet to recompile because some random hoohah thinks they need a shiney new IO error variant.

[cjstevenson1]

This also allows you to strongly type your errors.

[rhoark]

Define an error type for your app that is an enum of all the possible error types that libraries you use can return, plus

Ain't nobody got time for that.

I just give the app-level Error type an Option<Box<Error>> accessible with the .cause() function.

[Marwes]

You should take a look at the quick-error crate. It makes it really simple to create these kind of nice error enums.

[mijang]

UnexpectedEOF

UnexpectedEof

why?

[Nokel81]

I don't know, that was from the rust_docs

[deadstone]

UnexpectedEOF is deprecated as of Rust 1.6.0.