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

&self = immutable borrow, multiple allowed, read-only. &mut self = mutable borrow, exclusive, read-write. The borrow checker enforces these rules to prevent data races.

&self — shared read access:

• Multiple &self borrows can exist simultaneously.
• Cannot modify struct fields.
• Guarantees data stability during reads.
• Used for getters, display, queries.

1struct Stack<T> {
2    elements: Vec<T>,
3}
4
5impl<T: std::fmt::Debug> Stack<T> {
6    fn peek(&self) -> Option<&T> {
7        self.elements.last()
8    }
9
10    fn len(&self) -> usize {
11        self.elements.len()
12    }
13
14    fn is_empty(&self) -> bool {
15        self.elements.is_empty()
16    }
17}
18
19let stack = Stack { elements: vec![1, 2, 3] };
20println!("Top: {:?}", stack.peek());  // Some(3)
21println!("Len: {}", stack.len());       // 3

&mut self — exclusive write access:

• Only ONE &mut self at a time.
• Can modify struct fields.
• No other references while active.
• Used for setters and state changes.

1impl<T> Stack<T> {
2    fn push(&mut self, item: T) {
3        self.elements.push(item);
4    }
5
6    fn pop(&mut self) -> Option<T> {
7        self.elements.pop()
8    }
9
10    fn clear(&mut self) {
11        self.elements.clear();
12    }
13}
14
15let mut stack = Stack { elements: vec![1, 2, 3] };
16stack.push(4);    // push: &mut self
17stack.pop();      // pop: &mut self

When to use &self:

• Read-only methods.
• Multiple simultaneous borrows.
• Display, comparison, computation.

When to use &mut self:

• State-changing methods.
• Builder pattern.
• Exclusive access required.

Common mistakes:

• Missing let mut for &mut self methods.
• Holding &self while calling &mut self.
• Overusing &mut self.