Step 1 of 7

impl blocks and your first method

In the structs module you wrote functions like fn total_value(items: &[Item]). They work, but they float free: nothing ties them to the type, and you have to know their names to find them. A method is a function that belongs to a type. You define it inside an impl block (short for implementation), and its first parameter is self: the value the method was called on.

struct Rect {
    width: u32,
    height: u32,
}

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

    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

fn main() {
    let r = Rect { width: 8, height: 5 };
    println!("area: {}", r.area());
    println!("square? {}", r.is_square());
}

area: 40
square? false

Piece by piece:

• impl Rect { ... } holds the functions that belong to Rect. You can put as many methods in it as you like.
• &self is short for self: &Self, and inside an impl block Self means "the type this impl is for", here Rect. So area borrows the rectangle, reads it, and gives it back. It's the same &Rect parameter you'd write for a free function, with a special name.
• self.width reads a field of the value the method was called on.
• You call a method with a dot: r.area(). Rust passes &r as self for you (automatic referencing), so you never write (&r).area().

In fact r.area() is just a nicer way to write Rect::area(&r), and both compile to exactly the same code. Methods are about organization, not speed:

• Discoverability: type r. in an editor with rust-analyzer and you get a list of everything a Rect can do.
• Behavior lives next to its data: one place to look when you change the struct.
• Shorter names: r.area() instead of rect_area(&r). Different types can each have their own area method.

Common mistakes

• Forgetting self: a function in an impl without a self parameter has no value to read from:

struct Rect {
    width: u32,
    height: u32,
}

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

fn main() {
    let r = Rect { width: 2, height: 3 };
    println!("{}", r.area());
}

error[E0424]: cannot find value `self` in this scope

• Forgetting the parentheses: r.area (without ()) gives error[E0615]: attempted to take value of method `area` on type `Rect` . Fields are read without parentheses, methods are called with them.

Your task

Fill in the blanks so the program prints perimeter: 28: the keyword that starts the block, the parameter that borrows the square, the value whose side you read, and the method call.

Challenge 2

Add two methods to Rect:

• fn perimeter(&self) -> u32: twice the width plus twice the height.
• fn can_hold(&self, other: &Rect) -> bool: true if self is strictly wider and strictly taller than other.

A method can take more parameters after self, like any function.

Challenge 3

Write an impl block for Time (hours and minutes on a 24-hour clock) with two methods:

• fn total_minutes(&self) -> u32: minutes since midnight (9:30 is 570).
• fn is_before(&self, other: &Time) -> bool: true if self is earlier in the day than other. Call total_minutes from inside it with self.total_minutes().

Next: &mut self: methods that change the value