Option::map() / and_then() / is_some()

// Transforms the value inside Some using a closure; None is passed through unchanged.
let mapped = option.map(|x| x * 2);

// Applies a closure that returns an Option when the value is Some (flattens the result).
let chained = option.and_then(|x| some_func(x));

// Returns the alternative Option when the value is None.
let fallback = option.or(Some(42));

// Calls a closure to produce an alternative Option when the value is None.
let fallback = option.or_else(|| Some(compute()));

// Returns true if the value is Some.
let has_value = option.is_some();

// Returns true if the value is None.
let is_empty = option.is_none();

fn parse_positive(s: &str) -> Option<u32> {
    s.parse::<i32>().ok()                // Parses the string into an integer.
        .and_then(|n| if n > 0 { Some(n as u32) } else { None }) // Keeps only positive numbers.
}

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

    // Use map to transform the value.
    println!("{:?}", some_val.map(|x| x * 10)); // Some(50)
    println!("{:?}", none_val.map(|x| x * 10)); // None

    // Use and_then to chain a function that returns an Option.
    println!("{:?}", parse_positive("10")); // Some(10)
    println!("{:?}", parse_positive("-5")); // None
    println!("{:?}", parse_positive("abc")); // None

    // Use or to fall back when the value is None.
    println!("{:?}", none_val.or(Some(99)));   // Some(99)
    println!("{:?}", some_val.or(Some(99)));   // Some(5)

    // Use filter to convert a Some that fails the condition into None.
    println!("{:?}", some_val.filter(|&x| x > 3)); // Some(5)
    println!("{:?}", some_val.filter(|&x| x > 10)); // None

    // Use is_some / is_none to check the presence of a value.
    println!("{}", some_val.is_some()); // true
    println!("{}", none_val.is_none()); // true
}

The difference between map() and and_then() lies in what the closure returns. Use map() when the closure returns a plain value, and and_then() when it returns an Option. If the closure passed to and_then() does not return an Option, a compile error will occur.

Chaining these methods lets you express "transform if present → check condition → transform again" as a pipeline without nesting multiple match expressions. In Rust, this style is called the combinator pattern, drawing on ideas from functional programming.