Defining an Enum

In Rust, an enumeration, or `enum`, is a custom data type that allows you to define a type by enumerating its possible variants. Enums are fundamental for representing data that can be one of a set of distinct possibilities. Unlike structs, which group related pieces of data, enums represent a choice from a defined set of options.

Rust's enums are particularly powerful because each variant can optionally have data associated with it, much like structs. This makes them more expressive than enums in many other languages (like C++ or Java without special classes for each enum member), and they are often referred to as 'sum types' or 'algebraic data types'.

Key characteristics of Rust Enums:

1. Variant Types: Enum variants can be:
* Unit-like: Simple variants without any associated data (e.g., `TrafficLightColor::Red`).
* Tuple-like: Variants that hold data as a tuple (e.g., `Message::Move(x, y)`).
* Struct-like: Variants that hold named fields, similar to an anonymous struct within the enum (e.g., `Message::ChangeColor { r, g, b }`).

2. Syntax: An enum is defined using the `enum` keyword, followed by the enum's name and a block containing its variants:
```rust
enum Name {
Variant1,
Variant2(Type1, Type2),
Variant3 { field1: Type1, field2: Type2 },
}
```

3. Pattern Matching: The primary way to work with enums is through `match` expressions. A `match` expression allows you to execute different code blocks based on which variant an enum value is, and it can also extract any associated data from that variant. Rust's `match` is exhaustive, meaning the compiler ensures you handle every possible variant, preventing common bugs.

Benefits of using Enums:
* Type Safety: Ensures that a variable can only hold one of the predefined valid states.
* Clarity: Makes code more readable by explicitly stating the possible states or kinds of data.
* Expressiveness: Allows modeling complex domain concepts concisely.
* Error Prevention: The compiler's exhaustiveness check for `match` statements prevents unhandled cases.

Enums are widely used in Rust, notably in the standard library's `Option<T>` (for optional values: `Some(T)` or `None`) and `Result<T, E>` (for error handling: `Ok(T)` or `Err(E)`).

Example Code

enum TrafficLightColor {
    Red,
    Yellow,
    Green,
}

// An enum that can hold different types of web events.
enum WebEvent {
    // A unit-like variant
    PageLoad,
    PageUnload,
    // A tuple-like variant holding a char
    KeyPress(char),
    // A tuple-like variant holding a String
    Paste(String),
    // A struct-like variant holding two named i32 fields
    Click { x: i32, y: i32 },
}

// A function that processes different kinds of WebEvents
fn process_event(event: WebEvent) {
    match event {
        WebEvent::PageLoad => {
            println!("Page loaded.");
        },
        WebEvent::PageUnload => {
            println!("Page unloaded.");
        },
        WebEvent::KeyPress(c) => {
            println!("Key pressed: '{}'.", c);
        },
        WebEvent::Paste(s) => {
            // Note the double backslashes to escape the inner double quotes for JSON
            println!("Text pasted: \"{}\".", s);
        },
        WebEvent::Click { x, y } => {
            println!("Button clicked at ({}, {}).", x, y);
        },
    }
}

fn main() {
    // Creating instances of the TrafficLightColor enum
    let light_color = TrafficLightColor::Green;
    match light_color {
        TrafficLightColor::Red => println!("Stop!"),
        TrafficLightColor::Yellow => println!("Prepare to stop/go!"),
        TrafficLightColor::Green => println!("Go!"),
    }

    println!("\n--- Processing Web Events ---");

    // Creating instances of the WebEvent enum
    let load = WebEvent::PageLoad;
    let unload = WebEvent::PageUnload;
    let press = WebEvent::KeyPress('x');
    let paste = WebEvent::Paste(String::from("Rust programming is fun!"));
    let click = WebEvent::Click { x: 20, y: 50 };

    // Processing each event
    process_event(load);
    process_event(unload);
    process_event(press);
    process_event(paste);
    process_event(click);

    // Example of a more complex enum, often seen in networking or messaging systems
    enum Message {
        Quit, // No data
        Move { x: i32, y: i32 }, // Anonymous struct
        Write(String), // Tuple struct
        ChangeColor(i32, i32, i32), // Tuple struct
    }

    let msg = Message::Write(String::from("hello"));
    match msg {
        Message::Quit => println!("The application will quit."),
        Message::Move { x, y } => println!("Move to ({}, {})."),
        Message::Write(text) => println!("Message text: {}\n"),
        Message::ChangeColor(r, g, b) => println!("Change color to R:{}, G:{}, B:{}\n"),
    }
}

Example Code

Related Topics