R12: Error Handling

Question 1

panic!

Answer 1

Unrecoverable Errors.
~~~
fn main() {
panic!(“crash and burn”);
}
~~~

Question 2

Using a panic! Backtrace

Answer 2

A backtrace is a list of all the functions that have been called to get to this point.

Let’s try getting a backtrace by setting the RUST_BACKTRACE environment variable to any value except 0.

Example:

$ RUST_BACKTRACE=1 cargo run
thread ‘main’ panicked at ‘index out of bounds: the len is 3 but the index is 99’, src/main.rs:4:5
stack backtrace:
0: rust_begin_unwind
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/std/src/panicking.rs:584:5
1: core::panicking::panic_fmt
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:142:14
2: core::panicking::panic_bounds_check
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:84:5
3: <usize as core::slice::index::SliceIndex<[T]»::index
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:242:10
4: core::slice::index::<impl core::ops::index::Index<i> for [T]>::index
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:18:9
5: <alloc::vec::Vec<T,A> as core::ops::index::Index<i>>::index
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/alloc/src/vec/mod.rs:2591:9
6: panic::main
at ./src/main.rs:4:5
7: core::ops::function::FnOnce::call_once
at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/ops/function.rs:248:5
note: Some details are omitted, run with RUST_BACKTRACE=full for a verbose backtrace.</i></i>

Question 3

Handling Potential Failure with Result

Answer 3

Note that, like the Option enum, the Result enum and its variants have been brought into scope by the prelude, so we don’t need to specify Result:: before the Ok and Err variants in the match arms.

use std::fs::File;

fn main() {
let greeting_file_result = File::open(“hello.txt”);

let greeting_file = match greeting_file_result {
    Ok(file) => file,
    Err(error) => panic!("Problem opening the file: {:?}", error),
}; }

Question 4

Matching on Different Errors

Answer 4

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {:?}", e),
            },
            other_error => {
                panic!("Problem opening the file: {:?}", other_error);
            }
        },
    };
}

Question 5

Shortcuts for Panic on Error: unwrap

Answer 5

If the Result value is the Ok variant, unwrap will return the value inside the Ok. If the Result is the Err variant, unwrap will call the panic! macro for us.

Example:

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}

Question 6

Shortcuts for Panic on Error: expect

Answer 6

Similarly, the expect method lets us also choose the panic! error message.

use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be included in this project");
}

Question 7

Propagating Errors

Answer 7

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
let username_file_result = File::open(“hello.txt”);

let mut username_file = match username_file_result {
    Ok(file) => file,
    Err(e) => return Err(e),
};

let mut username = String::new();

match username_file.read_to_string(&mut username) {
    Ok(_) => Ok(username),
    Err(e) => Err(e),
} }

Question 8

A Shortcut for Propagating Errors: the ?

Answer 8

When the ? operator calls the from function, the error type received is converted into the error type defined in the return type of the current function

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();

    File::open("hello.txt")?.read_to_string(&mut username)?;

    Ok(username)
}