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

&self is an immutable reference to the instance — read-only access. &mut self is a mutable reference — read-write access, but exclusive (no other references allowed while it exists).

&self — immutable borrow:

• Multiple &self can coexist (aliasing is allowed).
• Cannot modify any field.
• Compiler guarantees data stability during reads.
• Ideal for getters, display, and query methods.

1struct TodoList {
2    items: Vec<String>,
3}
4
5impl TodoList {
6    fn count(&self) -> usize {
7        self.items.len()
8    }
9
10    fn is_empty(&self) -> bool {
11        self.items.is_empty()
12    }
13
14    fn contains(&self, item: &str) -> bool {
15        self.items.iter().any(|i| i == item)
16    }
17}
18
19let list = TodoList { items: vec!["Buy milk".into()] };
20println!("Count: {}", list.count());  // 1
21println!("Has milk: {}", list.contains("Buy milk"));  // true

&mut self — mutable borrow:

• Only ONE &mut self at a time (no aliasing).
• Can modify any field.
• While active, no other references can exist.
• Essential for state-changing operations.

1impl TodoList {
2    fn add(&mut self, item: String) {
3        self.items.push(item);
4    }
5
6    fn remove(&mut self, index: usize) -> Option<String> {
7        if index < self.items.len() {
8            Some(self.items.remove(index))
9        } else {
10            None
11        }
12    }
13
14    fn clear(&mut self) {
15        self.items.clear();
16    }
17}
18
19let mut list = TodoList { items: vec![] };
20list.add("Learn Rust".into());
21list.add("Build project".into());
22list.remove(0);

When to use &self:

• Reading data without side effects.
• Methods that compute or format output.
• When you want multiple simultaneous borrows.

When to use &mut self:

• Modifying struct state.
• Builder methods (returning &mut Self).
• Any operation that changes internal data.

Common mistakes:

• Forgetting let mut when calling &mut self methods.
• Holding &self while trying to call &mut self (borrow conflict).
• Making methods &mut self when &self works — limits chaining.