8.12 Method Syntax and Associated Functions

In Rust, you can associate functions with a specific type by defining them inside an impl block. These functions are split into two categories: methods and associated functions.

  • Methods operate on an instance of a type. Their first parameter is self, &self, or &mut self, and they are usually called using dot syntax, e.g., x.abs().
  • Associated functions belong to a type but do not operate on a specific instance. Since they do not take self, they are called by the type name, e.g., Rectangle::new(10, 20). They are often used as constructors or utilities.

8.12.1 Defining Methods and Associated Functions

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

impl Rectangle {
    // Associated function (no self)
    fn new(width: u32, height: u32) -> Self {
        Self { width, height }
    }

    // Method that borrows self immutably
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // Method that borrows self mutably
    fn set_width(&mut self, width: u32) {
        self.width = width;
    }
}

fn main() {
    let mut rect = Rectangle::new(10, 20); // Associated function call
    println!("Area: {}", rect.area());      // Method call
    rect.set_width(15);
    println!("New area: {}", rect.area());
}
  • Methods take self, &self, or &mut self as the first parameter to indicate whether they consume, borrow, or mutate the instance.
  • Associated functions do not have a self parameter and must be called with the type name.

8.12.2 Method Calls

Methods are called via dot syntax, for example rect.area(). When calling a method, Rust will automatically add references or dereferences as needed.

You can also call methods in associated function style by passing the instance explicitly:

struct Foo;

impl Foo {
    fn bar(&self) {
        println!("bar() was called");
    }
}

fn main() {
    let foo = Foo;
    foo.bar();      // Normal method call
    Foo::bar(&foo); // Equivalent call using the type name
}

This distinction between methods and associated functions is helpful when designing types that need both instance-specific behavior (methods) and general-purpose utilities (associated functions).