Result Type

Result is Rust's fundamental error handling type, representing either a successful value or an error condition with type safety guarantees.

Compare with Option

Result Type

Result


enum Result<T, E> {
   Ok(T),
   Err(E),
}

Common Use Cases

Result is used when a function can fail. Examples include file I/O, parsing operations, and network requests.

fn open_file(path: &str) -> Result<File, io::Error>

Common Result Methods

unwrap()

Returns the contained value or panics if the Result is an error

let x: i32 = Result::ok(5).unwrap();

expect(s)

Like unwrap, but allows custom error messages

let y = Result::err("custom").expect("Expected success");

map()

Maps a Result to Result using a function

let r = Ok(5).map(|x| x + 1);

Result in Action

Here's simple file reading example that uses Result for error handling

Example: File Reading


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

     fn open_file(file: &str) -> Result<File, io::Error> {
         File::open(file)
     }

     fn main() {
         match open_file("data.txt") {
             Ok(file) => {
                 // process file
             },
             Err(e) => {
                 eprintln!("Error: {}", e);
             }
         }
     }

Error Propagation


     fn read_config() -> Result<Config, io::Error> {
         let f = File::open("config.toml")?;
         // parse config
         Ok(Config {})
     }

Best Practices

Always use match or ? operator for proper error handling. Avoid unwrap in production code. Use the anyhow crate for error accumulation in larger projects.

Learn Advanced Patterns

Why Result Matters

Result forces you to think about error conditions at compile time, making Rust applications robust and reliable from the start. It's the cornerstone of Rust's error handling model.