Methods in Rust with impl, self, and Associated Functions

A method is a function associated with a type that typically works with its data.

In the previous article we defined Structs, which are great for storing data. Data that doesn’t do anything is a bit boring, so let’s give them behavior.

If you come from C# or Java, you’re used to defining the class and, within the same braces, writing the properties (data) and methods (behavior).

In Rust, this is done separately.

This separation is very clean and allows adding behavior to a type even across different files. Today we’ll see how to define methods, how to modify the instance with them, and what “static functions” are in Rust.

Defining methods with impl

Let’s bring back a classic example because it’s the easiest to visualize: a Rectangle.

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

To define a function that belongs to this struct (for example, to calculate its area), we open an impl Rectangle block:

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

The special parameter: &self

Notice the first parameter of the area function: &self.

In Rust, a function is considered a method when its first parameter is some form of self.

By using &self, we are saying: “To execute this function, I need to borrow (read) the instance I’m working on”.

To call the method, we use the dot syntax (.), just like in other languages:

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

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area() // Rust passes &rect1 automatically
    );
}

Types of self: reading, writing, and consuming

Just like with normal functions, methods are subject to the rules of Ownership. Depending on how we define the first parameter, the method will be able to do different things.

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

fn main() {
    let mut rect1 = Rectangle { width: 10, height: 20 };
    rect1.resize(2); // Modifies rect1
}

impl Rectangle {
    fn destroy(self) {
        println!("The rectangle has been destroyed and freed");
    } // Here, self goes out of scope and is destroyed along with its resources
}

Associated Functions

Inside the impl block, we can also define functions that do NOT take self as their first parameter.

Since they don’t have an instance to act upon, they are not methods, but associated functions of the type. They play a role similar to static methods in Java or C#.

The main use: constructors

Rust does not have a new keyword. To create instances, the convention is to define an associated function called new.

impl Rectangle {
    // Does not take &self. Returns a Rectangle (Self) instance
    fn new(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}

To call these functions, we don’t use the dot (.); we use the scope resolution operator ::.

fn main() {
    // StructName::AssociatedFunction
    let rect1 = Rectangle::new(30, 50);
}

Multiple impl blocks

Rust allows you to have multiple impl blocks for the same struct. This is useful for organizing code (though it’s not mandatory).

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

impl Rectangle {
    fn new(...) -> Rectangle { ... }
}

This will make much more sense when we see Traits (interfaces), where we will implement different traits in separate blocks.