Error Handling in Rust

# CHAPTER 15

Error Handling in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Understand when a program should panic!.

• Understand the Result<T, E> enum for recoverable errors.

• Extract successful data or error messages using match.

• Use unwrap() and expect() responsibly.

• Propagate errors up the call stack gracefully using the ? operator.

3. Unrecoverable Errors (panic!) #

You can trigger a panic manually using the panic! macro:

fn main() {
    panic!("CRITICAL FAILURE: Database connection lost!");
}

When a panic occurs, Rust cleans up memory, prints the error message, and shuts down the application.

4. Recoverable Errors (Result Enum) #

// The Result enum is built into the standard library like this:
enum Result<T, E> {
    Ok(T),  // Contains the success value
    Err(E), // Contains the error value
}

Let's attempt to open a file. The File::open function returns a Result.

use std::fs::File;

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

    // We MUST handle both the Ok and Err variants!
    let f = match f_result {
        Ok(file) => file, // Return the file handle
        Err(error) => panic!("Problem opening the file: {:?}", error), // Crash if missing
    };
}

5. Shortcuts: unwrap() and expect() #

• unwrap(): If the result is Ok, it returns the value inside. If the result is Err, it calls panic! automatically for you.

• expect("msg"): Exactly like unwrap, but lets you provide a custom panic message.

use std::fs::File;

fn main() {
    // If hello.txt doesn't exist, this line instantly crashes the program.
    let f = File::open("hello.txt").expect("Failed to open hello.txt");
}

*Rule of thumb: Only use unwrap or expect during prototyping, or when you are 100% mathematically certain the operation will not fail.*

6. Error Propagation (The ? Operator) #

Instead of writing massive match statements to return errors early, Rust provides the glorious ? operator.

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

// Notice the return type! It returns a Result containing either a String, or an io::Error.
fn read_username_from_file() -> Result<String, io::Error> {
    // If File::open fails, the '?' immediately stops this function and RETURNS the Err to the caller!
    // If it succeeds, the file handle is assigned to 'f'.
    let mut f = File::open("username.txt")?;
    
    let mut s = String::new();
    
    // If reading fails, '?' returns the error. If success, it proceeds.
    f.read_to_string(&mut s)?;
    
    // Return the successful string wrapped in Ok()
    Ok(s)
}

The ? operator eliminates almost all boilerplate error checking code!

7. Mini Project: Safe File Reader #

use std::fs;

fn main() {
    // fs::read_to_string does opening and reading in one step
    match fs::read_to_string("config.json") {
        Ok(contents) => println!("Config loaded: {}", contents),
        Err(e) => {
            println!("Warning: Could not read config file.");
            println!("System Reason: {}", e);
            println!("Falling back to default settings...");
        }
    }
}

8. Common Mistakes #

• Using ? inside main(): By default, main() returns an empty tuple (). The ? operator requires the function to return a Result. If you use ? in main(), it won't compile unless you change the signature of main to fn main() -> Result<(), Box<dyn std::error::Error>>.

• Overusing unwrap(): In a production server, using unwrap() is dangerous because any missing file or bad network connection will crash the entire server instance.

9. Best Practices #

• Embrace ?: Use the ? operator extensively to keep your functions clean and push error handling to the top level of your architecture.

10. Exercises #

1. 1. Write a function divide(a: f64, b: f64) -> Result<f64, String>.

1. 2. If b is 0.0, return Err(String::from("Cannot divide by zero")). Otherwise, return Ok(a / b).

1. 3. In main, call the function inside a match statement and print either the result or the error string.

11. MCQs with Answers #

Q1. Does Rust use try/catch Exceptions? a) Yes b) No, it uses the Type System (Result Enum) to handle errors Answer: b) No, it uses the Type System.

12. Interview Questions #

• Q: Contrast the Option enum with the Result enum. When do you use each? (Answer: Option is for absence of data, Result is for the presence of an error).

• Q: Explain how the ? operator reduces boilerplate code in error propagation.

13. Summary #

14. Next Chapter Recommendation #