Rust Error Handling Guide: unwrap, unwrap_or_else, ?, expect, and match

If you program in Rust, you may notice that error handling offers many options compared to C++, Java, or C. This guide reviews several common methods.

unwrap

The simplest but least safe method; calling unwrap() causes a panic if an error occurs. Use it only when you are certain the operation succeeds or you want the program to crash on failure.

<code>let mut x: i32 = 5;
x.try_into().unwrap();</code>

unwrap_or_else

A safer alternative to unwrap . If the result is Ok<T> or Some<T> , the value is returned; otherwise the provided closure runs. Useful for handling errors inline or when you need faster code than pattern matching.

<code>let mut x: i32 = 5;
x.try_into().unwrap_or_else(|e| panic!("Couldn't convert the i32. Error {}", e));</code>

?

The question‑mark operator can be used only in functions returning Result or Option . It propagates errors automatically and is often the most convenient way to handle them.

<code>fn setup<'a>(ttf_context: &'a Sdl2TtfContext,
             canvas: sdl2::render::Canvas<sdl2::video::Window>,
             event_pump: sdl2::EventPump,
             texture_creator: &'a sdl2::render::TextureCreator<sdl2::video::WindowContext>)
    -> Result<crate::Game::Game<'a>, String> {
    let current_path = std::env::current_dir().map_err(|e| e.to_string())?;
    // other code
}</code>

expect

expect also panics on error but lets you provide a custom error message, making it slightly safer than unwrap . Use it when you are confident the operation will not fail.

<code>let mut x: i32 = 5;
x.try_into().expect("Couldn't convert to a u32");</code>

Pattern Matching

Often the most flexible method; you can handle errors in any way, such as falling back to defaults.

<code>let current_path = match std::env::current_dir() {
    Ok(current_path) => current_path.join("assets"),
    Err(_e) => std::path::Path::new("assets").to_path_buf(),
};</code>

Now you know the various ways to handle errors in Rust.