How to do error handling in Rust and what are the common pitfalls?

by

Rust generally solves errors in two ways:

  • Unrecoverable errors. Once you panic!, that’s it. Your program or thread aborts because it encounters something it can’t solve and its invariants have been violated. E.g. if you find invalid sequences in what should be a UTF-8 string.

  • Recoverable errors. Also called failures in some documentation. Instead of panicking, you emit a Option<T> or Result<T, E>. In these cases, you have a choice between a valid value Some(T)/Ok(T) respectively or an invalid value None/Error(E). Generally None serves as a null replacement, showing that the value is missing.

Now comes the hard part. Application.

Unwrap

Sometimes dealing with an Option is a pain in the neck, and you are almost guaranteed to get a value and not an error.

In those cases it’s perfectly fine to use unwrap. unwrap turns Some(e) and Ok(e) into e, otherwise it panics. Unwrap is a tool to turn your recoverable errors into unrecoverable.

if x.is_some() {
    y = x.unwrap(); // perfectly safe, you just checked x is Some
    // ...
}

Inside the if-block it’s perfectly fine to unwrap since it should never panic because we’ve already checked that it is Some with x.is_some().

If you’re writing a library, using unwrap is discouraged because when it panics the user cannot handle the error. Additionally, a future update may change the invariant. Imagine if the example above had if x.is_some() || always_return_true() . The invariant would changed, and unwrap could panic.

In this example, you should use ìf let instead:

if let Some(y) = x {
    // ...
}

? operator / try! macro

What’s the ? operator or the try! macro? A short explanation is that it either returns the value inside an Ok() or prematurely returns error.

Here is a simplified definition of what the operator or macro expand to:

macro_rules! try {
    ($e:expr) => (match $e {
        Ok(val) => val,
        Err(err) => return Err(err),
    });
}

If you use it like this:

let x = File::create("my_file.txt")?;

let x = try!(File::create("my_file.txt"));

It will convert it into this:

let x = match File::create("my_file.txt") {
    Ok(val)  => val,
    Err(err) => return Err(err),
};

The downside is that your functions now return Result.

Combinators

Option and Result have some convenience methods that allow chaining and dealing with errors in an understandable manner. Methods like and, and_then, or, or_else, ok_or, map_err, etc.

For example, you could have a default value in case your value is botched.

let x: Option<i32> = None;
let guaranteed_value = x.or(Some(3)); //it's Some(3)

Or if you want to turn your Option into a Result.

let x = Some("foo");
assert_eq!(x.ok_or("No value found"), Ok("foo"));

let x: Option<&str> = None;
assert_eq!(x.ok_or("No value found"), Err("No value found"));

This is just a brief skim of things you can do. For more explanation, check out:

More Related Contents:

  1. How do you define custom `Error` types in Rust?
  2. Unable to read file contents to string – Result does not implement any method in scope named `read_to_string`
  3. What is the Rust equivalent to a try-catch statement?
  4. Where does PHP store the error log? (PHP 5, Apache, FastCGI, and cPanel)
  5. Analytics Google API Error 403: “User does not have any Google Analytics Account”
  6. Custom error pages for 404, 500 but where is the default 500 error message coming from?
  7. How do I write a Clojure threading macro?
  8. PHP Error handling: die() Vs trigger_error() Vs throw Exception
  9. What is unwrap in Rust, and what is it used for?
  10. batch file test error level
  11. Go checking for the type of a custom Error
  12. warning C4018: '<' : signed/unsigned mismatch [closed]
  13. I got an unknown error on my coding for a C program [closed]
  14. How do I create a heterogeneous collection of objects?
  15. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  16. Are polymorphic variables allowed?
  17. Efficiently mutate a vector while also iterating over the same vector
  18. Why do I need rebinding/shadowing when I can have mutable variable binding?
  19. Hide traceback unless a debug flag is set
  20. How can I put an async function into a map in Rust?
  21. What lifetimes do I use to create Rust structs that reference each other cyclically?
  22. Good error handling with file_get_contents [duplicate]
  23. How do I synchronously return a value calculated in an asynchronous Future?
  24. Removing elements from a Vec based on some condition [duplicate]
  25. Axios. How to get error response even when api return 404 error, in try catch finally
  26. What is the difference between a constant and a static variable and which should I choose?
  27. What’s the difference between using the return statement and omitting the semicolon in Rust?
  28. How to handle ETIMEDOUT error?
  29. Writing a generic function that takes an iterable container as parameter in Rust
  30. Expected closure, found a different closure

Leave a Comment