Basic

Structs can have different data types in them. The order of the fields doesn't matter.

Mutable Struct

Fields on their own cannot be mutable. The whole Struct has to be defined as mutable.

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

    user1.email = String::from("anotheremail@example.com");
}

Field Init Shorthand

Instead of writing username: username we can use the following shorthand syntax.

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

Struct Update Syntax

If we want to create a new struct based on an existing struct, we can use the struct update syntax. The ..user1 part must be on the bottom. Beware of the ownerships of the fields when using this syntax. Because fields with types that do not implement the Copy trait are moved, hence the ownership is transferred to the new struct. In this case user1.email is still usable, because its value was not moved out (because we assigned a new value to user2.email).

fn main() {
    // --snip--

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

Tuple Structs

Even tough the two structs Color and Point use the exact same types, they are not interchangeable. For example, a function that takes a parameter of type Color cannot take a Point as an argument.

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

Unit-like Structs

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

Ownership

lifetimes are needed to use references (fields in structs that do not own the data).

Methods

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

Associated Functions

Methods are associated functions, but there are also associated functions that aren't methods. Associated functions are always defined with an impl block. If they have self as their first parameter, they aren't methods.
Associated functions that aren’t methods are often used for constructors that will return a new instance of the struct.

new is not a special word in Rust! We can use any name we want.

impl Rectangle {
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

let sq = Rectangle::square(3);

The Self keywords in the return type and in the body of the function are aliases for the type that appears after the impl keyword, which in this case is Rectangle.

Each struct is allowed to have multiple impl blocks.