What is this question mark operator about?

by

As you may have noticed, Rust does not have exceptions. It has panics, but their use for error-handling is discouraged (they are meant for unrecoverable errors).

In Rust, error handling uses Result. A typical example would be:

fn halves_if_even(i: i32) -> Result<i32, Error> {
    if i % 2 == 0 {
        Ok(i / 2)
    } else {
        Err(/* something */)
    }
}

fn do_the_thing(i: i32) -> Result<i32, Error> {
    let i = match halves_if_even(i) {
        Ok(i) => i,
        Err(e) => return Err(e),
    };

    // use `i`
}

This is great because:

  • when writing the code you cannot accidentally forget to deal with the error,
  • when reading the code you can immediately see that there is a potential for error right here.

It’s less than ideal, however, in that it is very verbose. This is where the question mark operator ? comes in.

The above can be rewritten as:

fn do_the_thing(i: i32) -> Result<i32, Error> {
    let i = halves_if_even(i)?;

    // use `i`
}

which is much more concise.

What ? does here is equivalent to the match statement above with an addition. In short:

  1. It unpacks the Result if OK
  2. It returns the error if not, calling Into::into on the error value to potentially convert it to another type.

It’s a bit magic, but error handling needs some magic to cut down the boilerplate, and unlike exceptions it is immediately visible which function calls may or may not error out: those that are adorned with ?.

One example of the magic is that this also works for Option:

// Assume
// fn halves_if_even(i: i32) -> Option<i32>

fn do_the_thing(i: i32) -> Option<i32> {
    let i = halves_if_even(i)?;

    // use `i`
}

The ? operator, stabilized in Rust version 1.13.0 is powered by the (unstable) Try trait.

See also:

More Related Contents:

  1. Why is a trait not implemented for a type that clearly has it implemented?
  2. How can I include a module from another file from the same project?
  3. What does “Sized is not implemented” mean?
  4. Passing mutable self reference to method of owned object
  5. Rust proper error handling (auto convert from one error type to another with question mark)
  6. Why is a borrow still held in the else block of an if let?
  7. How to create a static string at compile time
  8. How to call a method when a trait and struct use the same method name?
  9. What does “cannot move out of index of” mean?
  10. How to convert ‘struct’ to ‘&[u8]’?
  11. How does the mechanism behind the creation of boxed traits work?
  12. What is the syntax: `instance.method::()`?
  13. Why does passing a closure to function which accepts a function pointer not work?
  14. “expected type parameter, found struct”
  15. Adding an append method to a singly linked list
  16. Is it possible to declare the type of the variable in Rust for loops?
  17. Lifetime of variables passed to a new thread
  18. How can I co-sort two Vecs based on the values in one of the Vecs?
  19. Is there a way to combine multiple traits in order to define a new trait? [duplicate]
  20. How can I store a pattern in a variable in Rust?
  21. How to avoid temporary allocations when using a complex key for a HashMap?
  22. Why does compilation not fail when a member of a moved value is assigned to?
  23. How to switch between Rust toolchains?
  24. What does “missing lifetime specifier” mean when storing a &str in a structure?
  25. Creating a vector of zeros for a specific size
  26. What is the difference between immutable and const variables in Rust?
  27. What is the purpose of the unit type in Rust?
  28. Cannot pass self as callback parameter due to double borrowing
  29. How to print structs and arrays?
  30. Can Rust optimise away the bit-wise copy during move of an object someday?

Leave a Comment