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 at compile time to prevent data races.

&self — shared read access:

• Any number of &self references can exist.
• Cannot modify fields.
• Guarantees data won't change during reads.
• Ideal for getters, display, and queries.

1struct User {
2    name: String,
3    email: String,
4    active: bool,
5}
6
7impl User {
8    fn name(&self) -> &str {
9        &self.name
10    }
11
12    fn is_active(&self) -> bool {
13        self.active
14    }
15
16    fn display(&self) {
17        println!("{} ({})", self.name, if self.active { "active" } else { "inactive" });
18    }
19}
20
21let user = User { name: "Alice".into(), email: "a@b.com".into(), active: true };
22user.display();  // &self
23let n = user.name();  // Another &self — OK!

&mut self — exclusive write access:

• Only ONE &mut self at a time.
• Can modify any field.
• No other references while active.
• Essential for state-changing operations.

1impl User {
2    fn deactivate(&mut self) {
3        self.active = false;
4    }
5
6    fn update_email(&mut self, email: String) {
7        self.email = email;
8    }
9
10    fn activate(&mut self) {
11        self.active = true;
12    }
13}
14
15let mut user = User { name: "Bob".into(), email: "b@c.com".into(), active: true };
16user.deactivate();  // &mut self
17user.update_email("new@email.com".into());

When to use &self:

• Any read-only operation.
• When you need multiple simultaneous borrows.
• Display, formatting, comparison methods.

When to use &mut self:

• Modifying struct state.
• Builder pattern.
• Operations requiring exclusive access.

Common mistakes:

• Forgetting let mut for &mut self methods.
• Holding &self while calling &mut self.
• Overusing &mut self when &self works.