Error Handling

Rust takes a unique approach to error handling — there are no exceptions. Instead, Rust uses the Result<T, E> enum for recoverable errors and panic! for unrecoverable errors. This makes error handling explicit and impossible to ignore.

---

Two Kinds of Errors

Kind	Mechanism	Example
Unrecoverable	panic! macro	Index out of bounds, corrupted state
Recoverable	Result<T, E> enum	File not found, invalid input, network timeout

Most errors in Rust are recoverable and should use Result.

---

panic! — Unrecoverable Errors

When something goes catastrophically wrong:

fn main() {
    panic!("crash and burn!");
}

When a panic! occurs:

1. The program prints an error message
2. The stack is unwound (by default) and memory is cleaned up
3. The program exits

When Does Rust Panic?

• Calling panic! explicitly
• Array index out of bounds
• Integer overflow in debug mode
• Calling .unwrap() on a None or Err

Tip: Set the environment variable RUST_BACKTRACE=1 to see a full backtrace when a panic occurs.

---

Result<T, E> — Recoverable Errors

The Result enum represents either success or failure:

enum Result<T, E> {
    Ok(T),   // success, containing a value of type T
    Err(E),  // failure, containing an error of type E
}

Using Result

use std::fs::File;

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

    let file = match file_result {
        Ok(f) => f,
        Err(e) => panic!("Could not open file: {e}"),
    };
}

Matching on Different Error Kinds

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

fn main() {
    let file = match File::open("hello.txt") {
        Ok(f) => f,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(f) => f,
                Err(e) => panic!("Could not create file: {e}"),
            },
            other => panic!("Could not open file: {other:?}"),
        },
    };
}

---

Shortcuts: unwrap and expect

unwrap

Returns the value inside Ok or panics on Err:

let file = File::open("hello.txt").unwrap();
// Panics with a generic message if the file does not exist

expect

Like unwrap, but with a custom panic message:

let file = File::open("hello.txt")
    .expect("hello.txt should be included in this project");

Tip: Prefer expect over unwrap — the custom message helps during debugging. In production code, prefer proper error handling over both.

---

The ? Operator

The ? operator propagates errors, making error handling concise:

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

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?;  // returns Err if it fails
    let mut username = String::new();
    file.read_to_string(&mut username)?;          // returns Err if it fails
    Ok(username)
}

The ? operator:

1. If the value is Ok(v), unwraps and returns v
2. If the value is Err(e), returns Err(e) from the enclosing function
3. Automatically converts error types using the From trait

Chaining with ?