Methods & Associated Functions

Methods are functions that are defined within the context of a struct (or enum or trait object). Their first parameter is always self, which represents the instance of the struct the method is being called on. Methods let you organize functionality that belongs to a type.

Defining Methods

Methods are defined within an impl (implementation) block:

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

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

Click Run to execute your code

Methods vs Associated Functions

The self Parameter

Methods can take ownership of self, borrow it immutably, or borrow it mutably:

1. &self (Immutable Borrow)

Most common. Read-only access to the instance:

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

2. &mut self (Mutable Borrow)

When you need to modify the instance:

fn scale(&mut self, factor: u32) {
    self.width *= factor;
    self.height *= factor;
}

3. self (Take Ownership)

Rare. Consumes the instance:

fn into_string(self) -> String {
    format!("{}x{}", self.width, self.height)
}

Associated Functions

Functions within impl blocks that don't take self are called associated functions. They're often used as constructors:

Click Run to execute your code

Multiple impl Blocks

You can have multiple impl blocks for the same type:

Click Run to execute your code

Automatic Referencing and Dereferencing

Rust automatically adds &, &mut, or * to match the method signature:

let rect = Rectangle { width: 30, height: 50 };

// These are equivalent
rect.area();
(&rect).area();

Method Call Syntax

Best Practices

Common Mistakes

// Wrong - Missing self parameter
impl Rectangle {
    fn area() -> u32 {  // Error: no self parameter
        self.width * self.height
    }
}

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

// Wrong - Unnecessary mutability
impl Rectangle {
    fn area(&mut self) -> u32 {  // Doesn't need to mutate
        self.width * self.height
    }
}

// Correct - Use &self for read-only operations
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

// Wrong - Trying to call associated function like a method
let rect = Rectangle::new(30, 50);
let area = rect.new(30, 50);  // Error: new doesn't have self

// Correct - Use :: for associated functions
let rect = Rectangle::new(30, 50);
let area = rect.area();  // Use . for methods

Exercise: Methods Practice

Click Run to execute your code

impl BankAccount {
    fn new(owner: String, initial_balance: f64) -> BankAccount {
        BankAccount {
            balance: initial_balance,
            owner,
        }
    }
    
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) -> bool {
        if self.balance >= amount {
            self.balance -= amount;
            true
        } else {
            false
        }
    }
    
    fn balance(&self) -> f64 {
        self.balance
    }
}

impl Temperature {
    fn from_celsius(celsius: f64) -> Temperature {
        Temperature { celsius }
    }
    
    fn from_fahrenheit(fahrenheit: f64) -> Temperature {
        Temperature {
            celsius: (fahrenheit - 32.0) * 5.0 / 9.0,
        }
    }
    
    fn to_fahrenheit(&self) -> f64 {
        self.celsius * 9.0 / 5.0 + 32.0
    }
    
    fn is_freezing(&self) -> bool {
        self.celsius <= 0.0
    }
}

Summary

What's Next?

Now that you understand structs and methods, you'll learn about enums - another way to create custom types. Enums let you define a type by enumerating its possible variants, and they're incredibly powerful when combined with pattern matching.