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

&self borrows the instance immutably — you can read data but not change it. &mut self borrows the instance mutably — you can both read and write, but exclusively (no other references allowed simultaneously).

&self — immutable borrow:

• Any number of &self borrows can exist at the same time.
• Cannot modify any field of the struct.
• The compiler guarantees the data won't change while you're reading it.
• Used for getter methods and read-only operations.

1struct BankAccount {
2    balance: f64,
3    owner: String,
4}
5
6impl BankAccount {
7    fn balance(&self) -> f64 {
8        self.balance
9    }
10
11    fn owner(&self) -> &str {
12        &self.owner
13    }
14}
15
16let account = BankAccount { balance: 1000.0, owner: "Alice".into() };
17let b = account.balance();  // &self
18let o = account.owner();    // Another &self — fine!
19println!("{}: {}", o, b);   // Alice: 1000

&mut self — mutable borrow:

• Only ONE &mut self can exist at a time (no aliases).
• Can modify any field of the struct.
• While &mut is active, no other references (&self or &mut self) can exist.
• Used for setter methods and state-changing operations.

1impl BankAccount {
2    fn deposit(&mut self, amount: f64) {
3        self.balance += amount;
4    }
5
6    fn withdraw(&mut self, amount: f64) -> bool {
7        if self.balance >= amount {
8            self.balance -= amount;
9            true
10        } else {
11            false
12        }
13    }
14}
15
16let mut account = BankAccount { balance: 1000.0, owner: "Alice".into() };
17account.deposit(500.0);   // &mut self
18account.withdraw(200.0);  // &mut self
19println!("{}", account.balance());  // 1300

When to use &self:

• Any read-only operation on the struct.
• Methods that compute or transform data without side effects.
• Display, formatting, comparison methods.

When to use &mut self:

• Methods that change struct state (setters, mutators).
• Builder-pattern methods returning &mut Self.
• Operations that need exclusive access to prevent data races.

Common mistakes:

• Calling &mut self methods on an immutable binding (must use let mut).
• Holding a &self reference while trying to call a &mut self method (borrow conflict).
• Making methods &mut self when &self suffices — reduces usability.