Rust Methods: Attaching Behavior to Data

Why it exists

To solve code organization. Instead of scattering functions that operate on a data type throughout a codebase, methods group all related behaviors directly with the data type itself inside an impl block. This makes the capabilities of a type easy to discover and manage.

The mental model

Think of methods as verbs for your nouns (structs). If a Rectangle struct is your data, its area() method is an action it can perform. Methods are defined in an impl (implementation) block, formally tying the behavior to the data structure it operates on.

How it works

Methods are functions defined inside an impl block whose first parameter is self, representing the instance of the type. This parameter specifies ownership: &self borrows immutably for reading, &mut self borrows mutably for modification, and self takes ownership, consuming the instance. When you call my_instance.my_method(), Rust automatically passes the instance as the first argument, a convenience known as method syntax. The type Self (with a capital S) inside an impl block is an alias for the type the block is for, so &self is shorthand for self: &Self.

When to use it

This is the idiomatic way to define behavior on structs and enums in Rust. Use methods to encapsulate logic that operates on an instance of a type. This leads to cleaner, more organized code compared to using standalone functions; for example, rect.area() is preferred over area(rect).

When not to use it

While methods are the default, a standalone function is better for logic that isn't tied to a single instance's state. If a function is a generic utility or operates on multiple unrelated types, it doesn't belong in an impl block for one specific type. Functions within an impl block that do not take self as a parameter are called associated functions, often used as constructors like String::new().

One canonical example

Given a struct Rectangle { width: u32, height: u32 }, you can define a method in an impl Rectangle block: fn area(&self) -> u32 { self.width * self.height }. This is called on an instance like let my_rect = Rectangle { ... }; let a = my_rect.area();. A common footgun is name collision. You could also have a method fn width(&self) -> bool { self.width > 0 }. Rust distinguishes by syntax: my_rect.width() calls the method, while my_rect.width accesses the field.