Enums and Pattern Matching

# CHAPTER 13

Enums and Pattern Matching #

1. Chapter Introduction #

2. Learning Objectives #

• Define basic Enums.

• Define Enums where variants hold embedded data.

• Master the Option<T> enum (Rust's replacement for null).

• Extract data from Enums using the match statement.

• Use the concise if let syntax for single pattern matching.

3. Basic Enums #

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;
}

4. Enums with Embedded Data (The Rust Superpower) #

enum IpAddr {
    V4(u8, u8, u8, u8), // Holds four integers
    V6(String),         // Holds a String
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));
}

*Notice how V4 holds a tuple of integers, and V6 holds a String. This flexibility is impossible in most languages.*

5. The Option Enum (Goodbye null!) #

// This is how Option is defined in the standard library:
enum Option<T> { // <T> means it can hold any type of data
    None,
    Some(T),
}

If a variable is an Option, the compiler *forces* you to check if it is None before you are allowed to use the data inside Some.

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

    // let total = 5 + some_number; // ERROR! You cannot add an i32 and an Option<i32>
}

6. Extracting Data with match #

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None, // If it's missing, return missing
        Some(i) => Some(i + 1), // If it has data (i), add 1 to it and wrap it back in Some
    }
}

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

*Because match is exhaustive, you cannot accidentally forget to handle the None case. Null pointer exceptions are mathematically impossible!*

7. The if let Syntax #

fn main() {
    let config_max = Some(3u8);

    // Using match:
    match config_max {
        Some(max) => println!("The maximum is configured to be {}", max),
        _ => (), // Do nothing for None
    }

    // Using if let (Shorter, cleaner!):
    if let Some(max) = config_max {
        println!("The maximum is configured to be {}", max);
    }
}

8. Common Mistakes #

• Assuming Option<T> is the same as T: Trying to use Some(5) as if it were just 5. The compiler treats them as completely different types. You must unpack it using match or unwrap() (which we will learn in Chapter 15).

• Forgetting Variants: When using a match on an Enum, forgetting to list one of the variants. The compiler will aggressively refuse to compile until every variant is handled.

9. Best Practices #

• Use Enums for State Machines: Enums are perfect for modeling states. For example, a WebConnection enum could be Disconnected, Connecting, or Connected(SocketData). The compiler guarantees you can only access the SocketData if the state is actually Connected.

10. Exercises #

1. 1. Define an Enum called Message with variants: Quit, Move { x: i32, y: i32 }, and Write(String).

1. 2. Create a function processmessage(msg: Message) that uses a match statement to print a different phrase depending on which message was passed.

Q10. Why is the Option pattern considered the ultimate solution to the "Billion Dollar Mistake"? a) Because it's faster b) Because the compiler mathematically proves at compile-time that you have checked for the absence of data before using it, making null pointer crashes impossible. Answer: b) Because it forces compile-time checking for data absence.

12. Interview Questions #

• Q: Describe how Rust eliminates the Null Pointer Exception using the type system.

• Q: Explain the syntax and use case for if let. Provide an example.

13. Summary #

14. Next Chapter Recommendation #