Why does Rust allow mutation through a reference field using an immutable binding?

by

A short way to explain this is that mutability in references and mutability in variables are orthogonal to each other. The two forms of mutability are related in the sense that we can only mutable borrow something from a mutable variable (or binding). Other than that, each binary combination is possible in Rust:

               reference mutability
            -----------------------------
variable   |     x: &T  |      x: &mut T |
mutability |------------+----------------|
           | mut x: &T  |  mut x: &mut T |
            -----------------------------

We can think of many samples of code exemplifying what can be done with such a variable x. For instance, an immutable variable of a mutable reference can modify one other element, but not itself:

let mut a = 5;
let mut b = 3;
let x: &mut i32 = &mut a;

*x = 10; // ok

x = &mut b; // nope! [E0384]
*x = 6;

Even as a field in a struct, this does not conflict with Rust’s safety guarantees. If a variable is immutably bound to a struct value, each of the fields will be immutable as well. In this example:

let mut x = 5;
let foo = Foo { 
    val: 6, 
    bar: Bar { val: 15 },
    val_ref: &mut x
};
*foo.val_ref = 10;

No mutations were applied to foo here: foo.val_ref still points to x. The former can be mutated because it’s mutably borrowed.
References are borrow-checked independently. The lifetime parameter 'a in Foo enables the compiler to keep track of the borrow.

That second example (shown below) does not work, because from a &Foo, we can only retrieve references to its fields (such as to val_ref: &mut i32). In turn, to prevent aliasing, a &&mut i32 can only be coerced to &i32. One cannot borrow data mutably through an immutable reference.

let foo_ref = &foo;
*foo_ref.val_ref = 10; // error[E0389]

Rust won’t let me do the same through an immutable reference. So an immutable reference has different behavior than an immutable binding.

Exactly!

See also:

More Related Contents:

  1. Why do I need to import a trait to use the methods it defines for a type?
  2. Should trait bounds be duplicated in struct and impl?
  3. How do I collect into an array?
  4. Can I do type introspection with trait objects and then downcast it?
  5. Cannot borrow as mutable more than once at a time in one code – but can in another very similar
  6. How can I perform parallel asynchronous HTTP GET requests with reqwest?
  7. Is it considered a bad practice to implement Deref for newtypes?
  8. Implementing a trait for multiple types at once
  9. Convert a String to int?
  10. How do I get an owned value out of a `Box`?
  11. Converting from Option to Option
  12. What is the difference between `e1` and `&e2` when used as the for-loop variable?
  13. Why doesn’t println! work in Rust unit tests?
  14. How do you use parent module imports in Rust?
  15. What does ‘let x = x’ do in Rust?
  16. If BufReader takes ownership of a stream, how can I read and write lines on it?
  17. How to fix lifetime error when function returns a serde Deserialize type?
  18. Is there another option to share an Arc in multiple closures besides cloning it before each closure?
  19. Why are recursive struct types illegal in Rust?
  20. Understanding Traits and Object Safety
  21. How do I pass a closure through raw pointers as an argument to a C function?
  22. Is there a way to use existing structs as enum variants?
  23. How can I create enums with constant values in Rust?
  24. How to embed resources in Rust executable?
  25. Sized is not implemented for the type Fn
  26. Extend lifetime of variable
  27. Can’t implement a trait I don’t own for all types that implement a trait I do own
  28. Is there a list of all cfg features?
  29. Comparing every element in a vector with the next one
  30. How can I build multiple binaries with Cargo?

Leave a Comment