The Result type and error handling

This lesson covers the Result type, which represents the outcome of an operation that might fail.

Result<T, E> is either Ok(value) on success or Err(error) on failure. Handling errors through this return value, rather than by throwing exceptions, is the Rust way.

The sample code defines a divide function that returns Err when asked to divide by zero, and uses match to write the success and failure paths.

A common early stumble is expecting exception handling like try/catch from other languages. Rust instead puts Result in the return type of anything that can fail, so the compiler stops you from forgetting to handle the error.

In professional work, most operations that can fail — reading a file, talking to the network — are implemented as functions returning a Result.

📖 Reference code

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        return Err(String::from("cannot divide by zero"));
    }
    Ok(a / b)
}

fn main() {
    match divide(10.0, 0.0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

✍️ Your code

Type your code, then press "Run"

🧪 This site can't compile or run Rust directly, so it checks on the spot whether what you typed matches the reference code (scoring happens entirely in your browser — nothing is sent anywhere).