Data Grouping with Structs and Enums

1. Structs: Grouping Related Data

Think about any object in a game, like a player character, an item, or in our case, a chess piece. These objects have a collection of properties or attributes. A struct (short for structure) is Rust's way of grouping these related properties into a single, named type.

If you've used C, structs will feel familiar. In Java, you can think of them as simple classes that only contain data fields (we'll add behavior later).

To get a clear picture of how to define and use structs, let's watch a short video.

As the video demonstrated, the concept is straightforward:

1. You define a struct with a name and a set of named fields, each with its own type.
2. You create an instance of that struct by providing values for each field.
3. You access the data in those fields using dot notation (e.g., user1.email).

Now, let's apply this to our chess game. How might we represent a single piece on the board? A piece has two fundamental properties: its type (Pawn, Rook, etc.) and its color (White or Black). We can't fully define this yet, but we can see how a struct would be the right tool to hold these two properties together.

2. Enums: Representing a Set of Choices

What about the color or the type of a piece? A piece's color can only be White or Black. Its type can only be one of Pawn, Rook, Knight, Bishop, Queen, or King. This is a classic "either/or" scenario where a value must be one of a fixed set of possibilities.

This is exactly what enums (enumerations) are for. An enum allows you to define a type by listing all its possible variants.

Since you're interested in games, a great analogy comes from the DEV Community article "Structs and Enums in Rust". In a Mario game, a power-up could be an enum with variants like SuperMushroom, FireFlower, or Starman. Mario can only have one of these at a time.

Rust's enums are more powerful than in languages like C, as they can also hold data. Let's see a video that explains this.

With enums, we now have the perfect tool to define our piece properties:

// Represents the type of a piece
enum PieceKind {
    Pawn,
    Rook,
    Knight,
    Bishop,
    Queen,
    King,
}

// Represents the color of a piece
enum PieceColor {
    White,
    Black,
}

These definitions are clean, type-safe, and clearly express our intent. You can't accidentally create a PieceColor::Green.

3. Hands-On: Modeling Our First Chess Piece

Now we can combine these two concepts to create our first data structure for the chess game. A chess piece is a single entity that has a color and a kind. Therefore, a struct is the right tool to group these properties, and our enums are the right tools for the properties themselves.

This is a common and effective pattern in Rust. A developer on Stack Overflow asked a similar question about how to model a chess board, and the answer provides a perfect illustration of this design.

Following this excellent advice, let's put it all together.

Your turn!

1. Open your rust_chess project and replace the contents of src/main.rs with the following code.
2. Read through it to see how struct and enum work together.
3. Run the code with cargo run.

// In src/main.rs

// An enum to represent the six types of chess pieces.
enum PieceKind {
    Pawn,
    Rook,
    Knight,
    Bishop,
    Queen,
    King,
}

// An enum to represent the two piece colors.
enum PieceColor {
    White,
    Black,
}

// A struct to represent a single chess piece.
// It groups the kind and color together.
struct Piece {
    kind: PieceKind,
    color: PieceColor,
}

fn main() {
    // Let's create an instance of a piece: a white king.
    let white_king = Piece {
        kind: PieceKind::King,
        color: PieceColor::White,
    };

    // Let's create another one: a black pawn.
    let black_pawn = Piece {
        kind: PieceKind::Pawn,
        color: PieceColor::Black,
    };
    
    // We can't print these structs to the console yet.
    // If you try to do println!("{:?}", white_king); you'll get a compiler error.
    // We will learn how to make them printable in a future lesson!
    
    println!("Successfully defined and created instances of our chess piece data structures!");
}

When you run this, it will simply print the success message. But don't be fooled by the simple output! You have just laid the foundational data model for your entire chess game using core Rust features.

Conclusion

In this lesson, we took a major step towards building our chess application. We moved from the abstract rules of ownership to the concrete task of data modeling.

Key Takeaways:

• Structs are used to group related data into a named, custom type. They are ideal for representing objects with multiple attributes (e.g., a Piece that has a kind and a color).
• Enums are used to define a type that can have one of several possible variants. They are perfect for representing a fixed set of choices (e.g., PieceColor can only be White or Black).
• Combining structs and enums is a powerful pattern in Rust for creating clear, expressive, and safe data models.

Our Piece struct is currently just a passive data container. It doesn't do anything. In our next lesson, we will learn how to attach behavior to our structs and enums using impl blocks. This will allow us to define methods, bringing our data structures to life.