Rust: What is the difference between &mut self and &self?

&self is an immutable borrow of the instance — you can read but not modify. &mut self is a mutable borrow — you can read and modify the instance, but only one mutable reference can exist at a time.

&self (immutable borrow):

• Multiple &self references can coexist simultaneously.
• Cannot modify any fields of the struct.
• Used for getters, display methods, and read-only operations.
• The compiler guarantees no data races since the data is read-only.

1struct Counter {
2    value: i32,
3}
4
5impl Counter {
6    fn get(&self) -> i32 {
7        self.value  // Just read, no modification
8    }
9
10    fn is_positive(&self) -> bool {
11        self.value > 0
12    }
13}
14
15let c = Counter { value: 5 };
16let v1 = c.get();  // &self borrow
17let v2 = c.get();  // Another &self borrow — OK!
18println!("{} {}", v1, v2);  // 5 5

&mut self (mutable borrow):

• Only ONE &mut self reference can exist at a time.
• Can modify fields of the struct.
• Used for setters, mutators, and state-changing operations.
• Prevents aliasing — no other references can exist while mutable borrow is active.

1impl Counter {
2    fn increment(&mut self) {
3        self.value += 1;  // Modify the field
4    }
5
6    fn set(&mut self, value: i32) {
7        self.value = value;  // Replace the field
8    }
9}
10
11let mut c = Counter { value: 5 };
12c.increment();  // &mut self borrow
13// let r = &c.value;  // Error! Cannot borrow as immutable while &mut exists
14println!("{}", c.get());  // 6 — OK after &mut borrow ends

When to use &self:

• Getter methods that return data or compute results.
• Display/Debug implementations.
• Any method that only reads the struct state.
• Allows calling multiple methods on the same instance simultaneously.

When to use &mut self:

• Setter methods that modify struct fields.
• Methods that update internal state.
• Builder-pattern methods that return &mut Self for chaining.
• Any method that needs to change the struct.

Common mistakes:

• Forgetting to mark the variable as mut when calling &mut self methods.
• Trying to hold both &self and &mut self at the same time (compiler error).
• Overusing &mut self when &self would suffice — limits flexibility.