Option<T>: When a Value Might Be Missing

Rust has no null. Instead, when a value might be absent, the type makes that explicit using Option<T>:

enum Option<T> {
    Some(T),
    None,
}

The compiler will not let you accidentally use a None as if it were a real value. To extract the inner value, you need to decide what to do if it is missing.

There are two main ways to unwrap an option. You can spell out both cases with pattern matching:

match find_user(id) {
    Some(name) => println!("found {name}"),
    None => println!("no such user"),
}

But for common cases there are shorter combinators:

let port = settings.port.unwrap_or(8080);     // value or fallback
let upper = name.map(|s| s.to_uppercase());   // transform if Some
let len = maybe_str.map_or(0, |s| s.len());   // transform-or-default

A Note on |x| ... (Closures)

Those |s| s.to_uppercase() and |s| s.len() bits are closures: anonymous functions you can pass as arguments. The pipes hold the parameters; everything after them is the body:

let add_one = |x| x + 1;
add_one(2); // 3

If the body needs multiple statements, wrap it in braces:

let greet = |name: &str| {
    let trimmed = name.trim();
    format!("hello, {trimmed}")
};

We'll use more closures in the iterators chapter. For this chapter, just read |s| s.len() as "a small function that takes s and returns s.len()."

When you only need to handle Some, you can use if let instead of a full match:

if let Some(user) = find_user(id) {
    println!("welcome, {user}");
}

Many standard-library methods return Option: .first() and .last() on slices, .next() and .find(...) on iterators, and .get() on slices and maps.

Transforming the Inside

You need the string's length in bytes when the Option is Some, and 0 when it's None. That means calling .len() on the inner string before returning the result. A match makes both branches explicit, while Option's combinator methods keep this common case shorter.

Useful from the Standard Library

• Option::map applies a function inside the Some and leaves None alone.
• Option::map_or handles both cases in one call, with a default for None and a closure for Some.

Producing an `Option<char>`

Now you have to produce an Option, not consume one. If the string is empty, there is no first character; Option<char> represents that case with None.

text.chars() returns an iterator, and every iterator's .next() returns Option<Item>. Call .next() on the iterator to get the first character, if there is one.

Useful from the Standard Library

• str::chars returns an iterator over the chars of the string.
• Iterator::next pulls one item off the iterator and returns it as Option<Item>. For the first character, that's Option<char> and exactly the return type.

Searching a Collection

Produce an Option by searching a slice of user records. The search returns a reference to a whole (u32, String) tuple, while the function must return only the username as Option<&str>. You need to borrow the username as &str without cloning the String. If the chain of calls gets hard to follow, pause after find and work out which type you have before adding map.

Useful from the Standard Library

• <[T]>::iter yields shared references to the slice's items, one at a time.
• Iterator::find takes a predicate closure and returns the first matching item as an Option.
• Option::map transforms the inner value when present. Here it pulls the username out of the tuple and converts it to &str.
• String::as_str is the explicit "borrow this String as &str" call.

Wrapping Up `Option`

You consumed Options with fallbacks and combinators, produced new ones from string and slice operations, and chained find and map to turn a search into the exact return type the signature asked for.

What We Learned

• Option<T> is Rust's stand-in for "value or absence". You cannot use it as a T without first extracting the value.
• You can use match to spell out both cases. For common patterns, reach for unwrap_or, map, and map_or to keep call sites short.
• if let Some(x) = ... is the lighter alternative to match when you only care about the Some branch.
• Option::map mirrors the iterator method of the same name: it transforms the inside if present, leaves None alone.
• Many standard-library operations already return Option: iter().next(), slice.first(), Vec::pop, HashMap::get, iter().find(...).
• unwrap and expect extract the value but panic on None. Use them in tests or when you've already ruled out None; otherwise prefer the safer combinators.
• The |x| ... syntax is a closure: a tiny anonymous function. It shows up everywhere with Option and iterators. We'll cover closures in more detail later.