09. structs_and_enums.md

9. Structs and Enums: Building Custom Data Types in Rust

Structs

Defining Structs in Rust

Structs are used to create custom data types with named fields, allowing you to group related data together. Rust supports two types of structs: structs with named fields and tuple structs.

• Named Fields Structs: Define structs with named fields, making it easy to access and modify individual fields by name.
• Tuple Structs: Define structs without named fields, using tuple-like syntax to specify the types of each field.

// Named Fields Struct
struct Person {
    name: String,
    age: u32,
}

// Tuple Struct
struct Point(i32, i32);

Methods and Associated Functions for Structs

Methods are functions associated with a particular struct or enum. Rust supports defining methods using the impl keyword followed by the struct's name. Additionally, structs can have associated functions that do not take an instance of the struct as a parameter.

impl Person {
    fn new(name: &str, age: u32) -> Person {
        Person {
            name: String::from(name),
            age,
        }
    }

    fn greet(&self) {
        println!("Hello, my name is {} and I am {} years old.", self.name, self.age);
    }
}

let person = Person::new("Alice", 30);
person.greet();

Enums

Defining Enums: Algebraic Data Types

Enums (enumerations) are a way to define a type that can be one of several variants. Each variant can optionally hold data of its own. Enums are useful for representing a fixed set of options or states.

enum Color {
    Red,
    Green,
    Blue,
}

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

Pattern Matching with Enums

Pattern matching allows you to match enums against patterns and execute different code based on the matched pattern. This is particularly useful when working with enums to handle different variants and associated data.

fn print_color(color: Color) {
    match color {
        Color::Red => println!("The color is red."),
        Color::Green => println!("The color is green."),
        Color::Blue => println!("The color is blue."),
    }
}

Using Enums for Error Handling and State Representation

Enums are commonly used for error handling by defining an Error variant that can hold additional information about the error. Enums can also be used to represent the state of a system or object, allowing for clear and concise code.

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

enum State {
    Running,
    Stopped,
    Paused,
}

Associated Data and Methods with Enums

Enums can have associated data and methods just like structs. This allows you to define behavior and data associated with each variant of the enum, making enums more versatile and powerful.

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

impl<T> Option<T> {
    fn is_some(&self) -> bool {
        match self {
            Option::Some(_) => true,
            Option::None => false,
        }
    }
}

Best Practices

• Use structs to group related data together and enums to represent a fixed set of options or states.
• Define methods and associated functions for structs and enums to encapsulate behavior and provide a clean API.
• Utilize pattern matching with enums for concise and expressive code that handles different cases gracefully.

Real-World Example

Imagine you're developing a game in Rust. You use structs to represent game entities such as players, enemies, and items, and enums to represent different states of the game such as running, paused, or game over. By leveraging structs and enums effectively, you can build a flexible and robust game engine.

Conclusion

Structs and enums are powerful tools in Rust for defining custom data types and representing various states and options. By understanding how to define and use structs and enums effectively, you'll be able to write clear, concise, and maintainable Rust code for a wide range of applications.