Enums and Option

Why enums?

Some values are "one of a few kinds". A payment is UPI, card or cash. An order is placed, shipped, delivered or cancelled. A struct says "this AND that"; an enum (short for enumeration) says "this OR that". Each possible kind is called a variant.

enum OrderStatus {
    Placed,
    Shipped,
    Delivered,
    Cancelled,
}

let s = OrderStatus::Shipped;

Variants that carry data

In Rust, each variant can hold different data. This is much more powerful than enums in C or Java, where variants are just named numbers.

enum Payment {
    Upi(String),                    // holds a UPI ID
    Card { last4: u16, network: String },
    Cash,
}

let p1 = Payment::Upi(String::from("asha@okbank"));
let p2 = Payment::Card { last4: 4242, network: String::from("RuPay") };
let p3 = Payment::Cash;

Enums can have methods too, in an impl block, just like structs. You will see in the next topic how match reads the data out of each variant.

The billion-dollar mistake: null

Many languages have null, a special value meaning "nothing here". Any variable might secretly be null, and using it crashes the program (NullPointerException in Java, "cannot read properties of null" in JavaScript). Tony Hoare, who introduced null in 1965, later called it his "billion-dollar mistake".

Option<T>

Rust has no null. When a value might be missing, its type says so: Option<T>. It is a normal enum from the standard library:

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

fn find_pincode(city: &str) -> Option<u32> {
    match city {
        "Jaipur" => Some(302001),
        "Patna" => Some(800001),
        _ => None,
    }
}

fn main() {
    let pin = find_pincode("Jaipur");
    // let next = pin + 1;   // error: cannot add an integer to Option<u32>
    if let Some(p) = pin {
        println!("PIN {p}");
    }
}

This is the key benefit. A plain u32 is always a real number. Only a value whose type is Option can be missing, and the compiler makes you handle that case. Missing values can no longer surprise you.

Useful Option methods

Many standard functions return Option: v.get(i) on a Vec, s.find('x') on a string, iter.max(), map.get(&key). Whenever something "might not be there", look for an Option.

Common mistakes

• Calling unwrap() everywhere. Each one is a possible crash. Use match, if let or unwrap_or.
• Writing Some for values that can never be missing. Use the plain type; Option only where absence is real.
• Comparing with null or using 0 as "missing". Use None.
• Forgetting the enum name: Shipped instead of OrderStatus::Shipped (unless you import the variants with use).