Rust Option

Rust doesn’t have null. If a value might be missing, that’s expressed directly in the type using Option. It feels like extra ceremony at first, but it closes off an entire category of bugs — the “null reference” that’s caused countless crashes in other languages.

What Option looks like

Option is an enum with two variants:

enum Option<T> {
    Some(T), // a value is present
    None,    // no value
}

You’ve actually already seen this — .get() on a vector and .get() on a HashMap both return an Option.

Creating an Option

fn main() {
    let has_value: Option<i32> = Some(5);
    let no_value: Option<i32> = None;

    println!("{:?}", has_value);
    println!("{:?}", no_value);
}

Output:

Some(5)
None

▶ Try it Yourself

Handling an Option with match

The safe way to get the value out is match — Rust forces you to handle both cases, so you can’t accidentally forget the “missing” case:

fn main() {
    let age: Option<i32> = Some(30);

    match age {
        Some(value) => println!("Age is {value}"),
        None => println!("No age given"),
    }
}

▶ Try it Yourself

A realistic example

fn find_user(id: u32) -> Option<&'static str> {
    if id == 1 {
        Some("Alice")
    } else {
        None
    }
}

fn main() {
    match find_user(1) {
        Some(name) => println!("Found: {name}"),
        None => println!("User not found"),
    }

    match find_user(99) {
        Some(name) => println!("Found: {name}"),
        None => println!("User not found"),
    }
}

Output:

Found: Alice
User not found

▶ Try it Yourself

Instead of returning null or throwing when a user isn’t found, the function’s return type itself tells every caller “this might not find anything” — and the compiler won’t let them ignore that possibility.

Shortcuts: unwrap_or and unwrap

For simple cases, a full match can feel like overkill. A couple of shortcuts:

fn main() {
    let age: Option<i32> = None;

    let value = age.unwrap_or(0); // fall back to 0 if there's no value
    println!("{value}");
}

▶ Try it Yourself

There’s also .unwrap(), which gives you the value directly — but panics (crashes) if it’s None:

let age: Option<i32> = Some(30);
let value = age.unwrap(); // fine here, since age is Some

Caution

Reach for .unwrap() in real code only when you’re certain the value is Some — for example, quick experiments or examples like the ones on this page. In production code, prefer match, unwrap_or, or the ? operator (covered on the next page) so a missing value doesn’t crash your whole program.

Recap

• Option<T> represents a value that might or might not be present — Rust has no null.
• Some(value) holds something; None means nothing is there.
• match is the safe way to handle both cases; the compiler won’t let you forget one.
• .unwrap_or(default) gives you a fallback; .unwrap() panics if the value is None — use it sparingly.

Quick check

Quick check

1. What does Rust use instead of null for a value that might be missing?

A special NullPointer typeAn empty StringOption<T>

2. What happens when you call .unwrap() on a None value?

It panicsIt returns a default valueIt silently returns None again

3. What does age.unwrap_or(0) do when age is None?

Panics with an errorFalls back to 0Converts None into Some(0) permanently

4. Why is match considered the safe way to get a value out of an Option?

It's faster than unwrapIt automatically converts None into a default valueThe compiler forces you to handle both Some and None cases

5. Which methods mentioned on this page already return an Option?

.push() on a vector.get() on a vector or HashMap.len() on a String

Score: 0 / 5

Read more

• The Option Enum — The Rust Book