Mutability, the ability to change something, works a bit differently in Rust than in other languages. The first aspect of mutability is its non-default status:
fn main() { let x = 5; x = 6; // error! }let x = 5; x = 6; // error!
We can introduce mutability with the mut
`mut` keyword:
let mut x = 5; x = 6; // no problem!
This is a mutable variable binding. When a binding is mutable, it means
you’re allowed to change what the binding points to. So in the above example,
it’s not so much that the value at x
`xis changing, but that the binding changed from one
` is changing, but that the binding
changed from one i32
`i32` to another.
If you want to change what the binding points to, you’ll need a mutable reference:
fn main() { let mut x = 5; let y = &mut x; }let mut x = 5; let y = &mut x;
y
`yis an immutable binding to a mutable reference, which means that you can’t bind
` is an immutable binding to a mutable reference, which means that you can’t
bind y
`yto something else (
` to something else (y = &mut z
`y = &mut z), but you can mutate the thing that’s bound to
`), but you can mutate the thing that’s
bound to y
`y(
` (*y = 5
`*y = 5`). A subtle distinction.
Of course, if you need both:
fn main() { let mut x = 5; let mut y = &mut x; }let mut x = 5; let mut y = &mut x;
Now y
`y` can be bound to another value, and the value it’s referencing can be
changed.
It’s important to note that mut
`mut` is part of a pattern, so you
can do things like this:
let (mut x, y) = (5, 6); fn foo(mut x: i32) {
However, when we say something is ‘immutable’ in Rust, that doesn’t mean that
it’s not able to be changed: We mean something has ‘exterior mutability’. Consider,
for example, Arc<T>
`Arc
use std::sync::Arc; let x = Arc::new(5); let y = x.clone();
When we call clone()
`clone(), the
`, the Arc<T>
`Arcneeds to update the reference count. Yet we’ve not used any
` needs to update the reference count. Yet
we’ve not used any mut
`muts here,
`s here, x
`xis an immutable binding, and we didn’t take
` is an immutable binding, and we didn’t take
&mut 5
`&mut 5` or anything. So what gives?
To understand this, we have to go back to the core of Rust’s guiding philosophy, memory safety, and the mechanism by which Rust guarantees it, the ownership system, and more specifically, borrowing:
You may have one or the other of these two kinds of borrows, but not both at the same time:
- one or more references (
&T
`&T`) to a resource.- exactly one mutable reference (
&mut T
`&mut T`)
So, that’s the real definition of ‘immutability’: is this safe to have two
pointers to? In Arc<T>
`Arc’s case, yes: the mutation is entirely contained inside the structure itself. It’s not user facing. For this reason, it hands out
`’s case, yes: the mutation is entirely contained inside
the structure itself. It’s not user facing. For this reason, it hands out &T
`&Twith
`
with clone()
`clone(). If it handed out
`. If it handed out &mut T
`&mut T`s, though, that would be a problem.
Other types, like the ones in the std::cell
`std::cell` module, have the
opposite: interior mutability. For example:
use std::cell::RefCell; let x = RefCell::new(42); let y = x.borrow_mut();
RefCell hands out &mut
`&mutreferences to what’s inside of it with the
` references to what’s inside of it with the
borrow_mut()
`borrow_mut()` method. Isn’t that dangerous? What if we do:
use std::cell::RefCell; let x = RefCell::new(42); let y = x.borrow_mut(); let z = x.borrow_mut();
This will in fact panic, at runtime. This is what RefCell
`RefCelldoes: it enforces Rust’s borrowing rules at runtime, and
` does: it enforces
Rust’s borrowing rules at runtime, and panic!
`panic!`s if they’re violated. This
allows us to get around another aspect of Rust’s mutability rules. Let’s talk
about it first.
Mutability is a property of either a borrow (&mut
`&mut) or a binding (
`) or a binding (let mut
`let mut). This means that, for example, you cannot have a [
`).
This means that, for example, you cannot have a struct
`struct` with
some fields mutable and some immutable:
struct Point { x: i32, mut y: i32, // nope }
The mutability of a struct is in its binding:
fn main() { struct Point { x: i32, y: i32, } let mut a = Point { x: 5, y: 6 }; a.x = 10; let b = Point { x: 5, y: 6}; b.x = 10; // error: cannot assign to immutable field `b.x` }struct Point { x: i32, y: i32, } let mut a = Point { x: 5, y: 6 }; a.x = 10; let b = Point { x: 5, y: 6}; b.x = 10; // error: cannot assign to immutable field `b.x`
However, by using Cell<T>
`Cell
use std::cell::Cell; struct Point { x: i32, y: Cell<i32>, } let point = Point { x: 5, y: Cell::new(6) }; point.y.set(7); println!("y: {:?}", point.y);
This will print y: Cell { value: 7 }
`y: Cell { value: 7 }. We’ve successfully updated
`. We’ve successfully updated y
`y`.