What does the ? operator do in Rust?

The ? operator unwraps an Ok value or returns early on Err, automatically applying the From trait to convert the error into the function's declared error type. It is the idiomatic way to propagate failures without manual match statements.

What is the difference between unwrap and the ? operator?

unwrap (and expect) returns the value or panics, terminating the thread, so it is only safe when failure is genuinely impossible. The ? operator instead returns the error to the caller, keeping the program recoverable, and is preferred in any function that returns Result.

When should I use anyhow versus thiserror?

Use thiserror in libraries to derive a typed error enum that callers can match on, often with #[from] for conversions. Use anyhow in applications, where a single boxed anyhow::Error with added context() is more convenient than defining your own enum.

What is io::ErrorKind used for?

io::Error carries an ErrorKind enum that categorises the failure portably, such as NotFound, PermissionDenied, or TimedOut. Matching on err.kind() lets you handle specific cases without depending on the raw OS error number.

Is anything I search uploaded?

No. The full reference and the search run entirely in your browser. Nothing you type is sent anywhere.

Rust Error Reference

This is a searchable reference for Rust error handling — the std::error::Error trait, the Result/Option enums, the io::ErrorKind variants, the standard parse error types (ParseIntError, Utf8Error), and the conventions of the widely used anyhow and thiserror crates.

How it works

Rust has no exceptions. Fallible operations return Result<T, E> (either Ok(T) or Err(E)), and absence is modelled with Option<T>. The std::error::Error trait unifies error values and exposes source() to walk a cause chain. Concrete errors like io::Error carry an ErrorKind enum — NotFound, PermissionDenied, TimedOut — so you can match on the category portably with err.kind() instead of inspecting raw OS numbers.

You propagate failures with the ? operator. Applied to a Result, it returns early on Err, automatically calling From to convert that error into the function’s declared error type. Libraries typically define their own error enum (often derived with thiserror and #[from] for those conversions), while applications box everything behind anyhow::Error and attach human-readable context().

Example

Parse a number, propagate the error, then inspect an I/O kind:

use std::io::{self, ErrorKind};

fn read_port(s: &str) -> Result<u16, Box<dyn std::error::Error>> {
    let n: u16 = s.trim().parse()?;   // ? converts ParseIntError via From
    Ok(n)
}

match std::fs::read("config.toml") {
    Ok(bytes) => { /* ... */ }
    Err(e) if e.kind() == ErrorKind::NotFound => { /* use defaults */ }
    Err(e) => return Err(e.into()),
}

Reach for unwrap() only when failure is truly impossible — otherwise prefer ?, which keeps the program recoverable instead of panicking. Everything runs in your browser; nothing is uploaded.

Rust Error Reference

Email me this result

How it works

Example