Structs: your own data types

Why structs?

A tuple like ("Asha", 21, "Pune") works, but nobody can tell what 21 means without reading other code. A struct gives each value a name. A struct is a custom data type that groups related values, called fields. It is like a form with labelled boxes.

struct Student {
    name: String,
    roll: u32,
    city: String,
    active: bool,
}

fn main() {
    let s = Student {
        name: String::from("Asha"),
        roll: 21,
        city: String::from("Pune"),
        active: true,
    };
    println!("{} (roll {}) from {}", s.name, s.roll, s.city);
}

An instance is one actual value made from the blueprint. Field order in the instance does not matter, but every field must be given a value. Rust has no "undefined" or "missing" fields.

Structs have no hidden cost. In memory, a struct is just its fields placed next to each other, so using a struct instead of separate variables does not make your program slower.

Changing fields

To change any field, the whole instance must be mut. Rust does not allow marking only some fields as mutable.

let mut s = Student { name: String::from("Ravi"), roll: 4, city: String::from("Nagpur"), active: true };
s.city = String::from("Mumbai");

Handy shortcuts

fn new_student(name: String, roll: u32) -> Student {
    Student {
        name,             // field init shorthand: same as name: name
        roll,
        city: String::from("Unknown"),
        active: true,
    }
}

let a = new_student(String::from("Neha"), 7);
let b = Student {
    name: String::from("Kiran"),
    roll: 8,
    ..a                   // struct update: take the other fields from a
};

Tuple structs and unit structs

struct Rupees(u64);          // tuple struct: one unnamed field
struct Point(i32, i32);

struct Online;               // unit struct: no fields at all

let price = Rupees(499);
println!("{}", price.0);     // 499

This idea, wrapping a simple value in a named type for safety, is called the newtype pattern. fn pay(amount: Rupees) can never receive a raw number or a distance by mistake.

Printing a struct

#[derive(Debug)]
struct Train {
    number: u32,
    name: String,
}

fn main() {
    let t = Train { number: 12002, name: String::from("Shatabdi") };
    println!("{:?}", t);
    println!("{:#?}", t);
}

#[derive(Debug)] is an attribute that asks the compiler to write the Debug printing code for you. Structs do not get {} printing automatically, because there is no single obvious way to show them to users; you implement Display yourself (module 7).

Ownership inside structs

Fields like String are owned by the struct. When the struct is dropped, all its fields are dropped too. That is why we used String instead of &str: the struct owns its data and needs no lifetimes (see module 4).

Common mistakes

• Forgetting a field when creating an instance: "missing field city". Give every field a value.
• Trying to change a field of a non-mut instance. Use let mut.
• Printing with {} and getting "doesn't implement std::fmt::Display". Use {:?} with #[derive(Debug)].
• Using ..other and then being surprised that other's String fields were moved.