Enums & Pattern Matching

Intermediate ~30 min read

Enums allow you to define a type by enumerating its possible variants. Unlike structs, which group related data together, enums let you say a value is one of a possible set of values. Enums are incredibly powerful in Rust, especially when combined with pattern matching.

Defining Enums

Here's a simple enum:

enum IpAddrKind {
    V4,
    V6,
}

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

Enums with Data

Enum variants can have associated data:

fn main() {
    // Define an enum
    enum IpAddrKind {
        V4,
        V6,
    }
    
    // Create enum values
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;
    
    // Enums with data
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }
    
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));
    
    // Enum with different types
    enum Message {
        Quit,                       // No data
        Move { x: i32, y: i32 },   // Named fields
        Write(String),              // Single String
        ChangeColor(i32, i32, i32), // Three i32s
    }
    
    let msg1 = Message::Quit;
    let msg2 = Message::Move { x: 10, y: 20 };
    let msg3 = Message::Write(String::from("hello"));
    let msg4 = Message::ChangeColor(255, 0, 0);
    
    // Match on enums
    match msg2 {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write: {}", text),
        Message::ChangeColor(r, g, b) => println!("Color: ({}, {}, {})", r, g, b),
    }
}

// Enums can have methods too!
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

impl TrafficLight {
    fn time(&self) -> u32 {
        match self {
            TrafficLight::Red => 60,
            TrafficLight::Yellow => 3,
            TrafficLight::Green => 45,
        }
    }
}

Output

Click Run to execute your code

Flexibility: Each variant can have different types and amounts of associated data. This is more flexible than using multiple structs!

The Option Enum

Rust doesn't have null. Instead, it has Option<T>:

enum Option {
    Some(T),
    None,
}

Option<T> is so useful it's included in the prelude - you don't need to import it!

fn main() {
    // Option<T> - represents a value that might be absent
    let some_number = Some(5);
    let some_string = Some("a string");
    let absent_number: Option<i32> = None;
    
    // Using Option with match
    let x = Some(5);
    let y = 10;
    
    match x {
        None => println!("x is None"),
        Some(i) => println!("x is {}", i),
    }
    
    // Option methods
    let value = Some(42);
    
    // unwrap_or - provide default
    let result = value.unwrap_or(0);
    println!("Result: {}", result);
    
    let none_value: Option<i32> = None;
    let result = none_value.unwrap_or(0);
    println!("Result with None: {}", result);
    
    // is_some and is_none
    if value.is_some() {
        println!("Value exists!");
    }
    
    if none_value.is_none() {
        println!("No value!");
    }
    
    // map - transform the value if it exists
    let doubled = value.map(|x| x * 2);
    println!("Doubled: {:?}", doubled);
    
    // and_then - chain operations
    let result = Some(4)
        .and_then(|x| Some(x * 2))
        .and_then(|x| Some(x + 1));
    println!("Chained: {:?}", result);
    
    // Practical example
    fn divide(numerator: f64, denominator: f64) -> Option<f64> {
        if denominator == 0.0 {
            None
        } else {
            Some(numerator / denominator)
        }
    }
    
    match divide(10.0, 2.0) {
        Some(result) => println!("Result: {}", result),
        None => println!("Cannot divide by zero!"),
    }
    
    match divide(10.0, 0.0) {
        Some(result) => println!("Result: {}", result),
        None => println!("Cannot divide by zero!"),
    }
}

// Option is defined as:
// enum Option<T> {
//     None,
//     Some(T),
// }

Output

Click Run to execute your code

No Null Pointer Errors: By using Option<T>, Rust forces you to handle the case where a value might be absent, preventing null pointer errors at compile time!

The Result Enum

Result<T, E> is used for error handling:

enum Result {
    Ok(T),
    Err(E),
}

fn main() {
    // Result<T, E> - for operations that can fail
    fn divide(a: i32, b: i32) -> Result<i32, String> {
        if b == 0 {
            Err(String::from("Division by zero"))
        } else {
            Ok(a / b)
        }
    }
    
    // Using Result with match
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
    
    match divide(10, 0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
    
    // Result methods
    let success: Result<i32, &str> = Ok(42);
    let failure: Result<i32, &str> = Err("something went wrong");
    
    // unwrap_or
    println!("Success unwrap_or: {}", success.unwrap_or(0));
    println!("Failure unwrap_or: {}", failure.unwrap_or(0));
    
    // is_ok and is_err
    if success.is_ok() {
        println!("Operation succeeded!");
    }
    
    if failure.is_err() {
        println!("Operation failed!");
    }
    
    // map and map_err
    let doubled = success.map(|x| x * 2);
    println!("Doubled: {:?}", doubled);
    
    // Practical example: File operations
    use std::fs::File;
    use std::io::ErrorKind;
    
    let file_result = File::open("hello.txt");
    
    let file = match file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => {
                println!("File not found, would create it");
                return;
            }
            other_error => {
                println!("Problem opening file: {:?}", other_error);
                return;
            }
        },
    };
    
    println!("File opened successfully!");
}

// Result is defined as:
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }

Output

Click Run to execute your code

Pattern Matching with match

The match expression is extremely powerful for working with enums:

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

Exhaustive Matching: match expressions must be exhaustive - you must handle every possible case!

Matching with Data

You can extract data from enum variants:

enum Message {
    Move { x: i32, y: i32 },
    Write(String),
}

fn process(msg: Message) {
    match msg {
        Message::Move { x, y } => {
            println!("Move to ({}, {})", x, y);
        }
        Message::Write(text) => {
            println!("Text: {}", text);
        }
    }
}

The if let Syntax

For when you only care about one variant:

let some_value = Some(3);

// Using match
match some_value {
    Some(3) => println!("three"),
    _ => (),
}

// Using if let - more concise!
if let Some(3) = some_value {
    println!("three");
}

Enum Methods

Enums can have methods just like structs:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn call(&self) {
        match self {
            Message::Quit => println!("Quit"),
            Message::Move { x, y } => println!("Move to ({}, {})", x, y),
            Message::Write(text) => println!("Write: {}", text),
        }
    }
}

Common Option Methods

Method	Description	Example
`is_some()`	Returns true if Some	`value.is_some()`
`is_none()`	Returns true if None	`value.is_none()`
`unwrap_or(default)`	Returns value or default	`value.unwrap_or(0)`
`map(f)`	Transform the value	`value.map(\|x\| x * 2)`

Best Practices

Use Option instead of null: Prevents null pointer errors
Use Result for error handling: Makes errors explicit
Prefer match for exhaustive handling: Compiler ensures all cases covered
Use if let for single variant: More concise when you only care about one case
Add methods to enums: Encapsulate behavior with the data
Use descriptive variant names: Make code self-documenting

Common Mistakes

1. Not handling all enum variants in match

// Wrong - Not exhaustive
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        // Error: non-exhaustive patterns
    }
}

// Correct - Handle all cases
fn value(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

2. Using unwrap() without checking Option/Result

// Wrong - Can panic at runtime
let value = some_option.unwrap();  // Panics if None
let result = some_result.unwrap();  // Panics if Err

// Correct - Handle the cases properly
match some_option {
    Some(value) => println!("Value: {}", value),
    None => println!("No value"),
}

// Or use unwrap_or for defaults
let value = some_option.unwrap_or(0);

3. Forgetting to use :: for enum variants

// Wrong - Missing :: operator
enum IpAddrKind {
    V4,
    V6,
}

let addr = V4;  // Error: cannot find value `V4` in this scope

// Correct - Use :: to access enum variants
let addr = IpAddrKind::V4;

4. Not extracting data from enum variants properly

// Wrong - Can't access variant data directly
enum Message {
    Write(String),
    Move { x: i32, y: i32 },
}

let msg = Message::Write(String::from("hello"));
println!("{}", msg.text);  // Error: no field `text`

// Correct - Use match or if let to extract
match msg {
    Message::Write(text) => println!("{}", text),
    Message::Move { x, y } => println!("Move to ({}, {})", x, y),
}

Exercise: Enums Practice

Task: Implement enums for shapes and web events.

// Exercise: Enums Practice

fn main() {
    // TODO: Define a Shape enum with variants for Circle, Rectangle, and Triangle
    // Circle should contain radius (f64)
    // Rectangle should contain width and height (f64, f64)
    // Triangle should contain base and height (f64, f64)
    
    // TODO: Implement area method for Shape
    
    // TODO: Define a WebEvent enum
    // PageLoad
    // PageUnload
    // KeyPress(char)
    // Click { x: i64, y: i64 }
    
    // TODO: Implement inspect method that prints event details
    
    // TODO: Write a function that returns Option<i32>
    // find_first_even that takes a Vec<i32> and returns the first even number
    
    // TODO: Write a function that returns Result<f64, String>
    // safe_sqrt that returns Ok(sqrt) for positive numbers, Err for negative
}

// Hints:
// 1. Use enum Name { Variant1, Variant2(Type), Variant3 { field: Type } }
// 2. Implement methods with impl EnumName { fn method(&self) { match self { ... } } }
// 3. Use Option::Some(value) or Option::None
// 4. Use Result::Ok(value) or Result::Err(error)
// 5. Match on enum variants to extract data

Output

Click Run to execute your code

Show Solution

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Triangle(f64, f64),
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(r) => std::f64::consts::PI * r * r,
            Shape::Rectangle(w, h) => w * h,
            Shape::Triangle(b, h) => 0.5 * b * h,
        }
    }
}

enum WebEvent {
    PageLoad,
    PageUnload,
    KeyPress(char),
    Click { x: i64, y: i64 },
}

impl WebEvent {
    fn inspect(&self) {
        match self {
            WebEvent::PageLoad => println!("Page loaded"),
            WebEvent::PageUnload => println!("Page unloaded"),
            WebEvent::KeyPress(c) => println!("Key pressed: {}", c),
            WebEvent::Click { x, y } => println!("Clicked at ({}, {})", x, y),
        }
    }
}

fn find_first_even(numbers: Vec) -> Option {
    for num in numbers {
        if num % 2 == 0 {
            return Some(num);
        }
    }
    None
}

fn safe_sqrt(x: f64) -> Result {
    if x < 0.0 {
        Err(String::from("Cannot take square root of negative number"))
    } else {
        Ok(x.sqrt())
    }
}

Summary

Enums define a type by enumerating variants
Variants can have associated data
Option<T> replaces null - Some(T) or None
Result<T, E> for error handling - Ok(T) or Err(E)
match expression for pattern matching
Match must be exhaustive
if let for matching single variant
Enums can have methods via impl blocks
Enums are zero-cost abstractions
Pattern matching is compile-time checked

What's Next?

Congratulations! You've completed the Structs & Enums module. You now know how to create custom types with structs and enums, add methods to them, and use pattern matching to handle different cases safely.

In the next modules, you'll learn about collections (vectors, strings, hash maps), error handling in depth, and more advanced Rust features that build on these foundations.

Previous Methods

Next Vectors

Defining Enums

Enums with Data

The Option Enum

The Result Enum

Pattern Matching with match

Matching with Data

The if let Syntax

Enum Methods

Common Option Methods

Best Practices

Common Mistakes

1. Not handling all enum variants in match

2. Using unwrap() without checking Option/Result

3. Forgetting to use :: for enum variants

4. Not extracting data from enum variants properly

Exercise: Enums Practice

Summary

What's Next?

Enjoying these tutorials?