Defining and Instantiating Structs

Structs (or structures) in Rust are custom data types that allow you to group multiple related values together. They are similar to objects or classes in other languages, but without inheritance.

Defining a Struct

To define a struct, we use the struct keyword followed by the name in PascalCase. Inside, we define the names and types of the fields:

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

Creating an Instance

To use a struct, we must create an instance by filling in all the specified fields:

fn main() {
    let user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    // Access fields using dot notation
    println!("Is user {} active? {}", user1.username, user1.active);
}

Struct Mutability

In Rust, the entire instance must be marked as mutable (mut) if you want to modify any of its fields. Rust does not allow marking only certain fields as mutable:

fn main() {
    let mut user1 = User {
        email: String::from("alice@example.com"),
        username: String::from("alice123"),
        active: true,
        sign_in_count: 1,
    };

    user1.active = false; // Valid because user1 is mutable!
}

Tuple Structs and Unit-Like Structs

Rust also supports two other struct formats besides classic named-field structs:

1. Tuple Structs: They have an associated name but the fields do not have individual names, only types. They are useful for defining and differentiating specific types:
   Code

   Copia

   struct Point(i32, i32, i32);
   let origin = Point(0, 0, 0);
   

2. Unit-Like Structs: They do not define any fields. They behave like the () unit type. They are useful when you need to implement behaviors (traits) on a type without storing any data in it.

Try it yourself