Why does creating a mutable reference to a dereferenced mutable reference work?

by

The rule

There shall only be one usable mutable reference to a particular value at any point in time.

This is NOT a spatial exclusion (there CAN be multiple references to the same piece) but a temporal exclusion.

The mechanism

In order to enforce this, &mut T is NOT Copy; therefore calling:

test(mutable_reference);

should move the reference into test.

Actually doing this would make it unusable later on and not be very ergonomic, so the Rust compiler inserts an automatic reborrowing, much like you did yourself:

test(&mut *mutable_reference);

You can force the move if you wanted to:

test({ let x = mutable_reference; x });

The effect

Re-borrowing is, in essence, just borrowing:

  • mutable_reference is borrowed for as long as the unnamed temporary mutable reference exists (or anything that borrows from it),
  • the unnamed temporary mutable reference is moved into test,
  • at the of expression, the unnamed temporary mutable reference is destroyed, and therefore the borrow of mutable_reference ends.

More Related Contents:

  1. Why is a trait not implemented for a type that clearly has it implemented?
  2. How can I include a module from another file from the same project?
  3. What does “Sized is not implemented” mean?
  4. Deriving a trait results in unexpected compiler error, but the manual implementation works
  5. How do I implement a trait I don’t own for a type I don’t own?
  6. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  7. What makes something a “trait object”?
  8. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  9. What is the relation between auto-dereferencing and deref coercion?
  10. What is the return type of the indexing operation?
  11. How to do a binary search on a Vec of floats?
  12. Change enum variant while moving the field to the new variant
  13. I implemented a trait for another trait but cannot call methods from both traits
  14. When is it useful to define multiple lifetimes in a struct?
  15. Can I write an Iterator that mutates itself and then yields a reference into itself?
  16. How do I specify lifetime parameters in an associated type?
  17. What is the difference between Copy and Clone?
  18. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  19. Temporary value is freed at the end of this statement [duplicate]
  20. What is the right way to allocate data to pass to an FFI call?
  21. Sharing a struct with trait objects as properties across threads
  22. How can I store a pattern in a variable in Rust?
  23. How to avoid temporary allocations when using a complex key for a HashMap?
  24. Why does compilation not fail when a member of a moved value is assigned to?
  25. How to switch between Rust toolchains?
  26. What does “missing lifetime specifier” mean when storing a &str in a structure?
  27. Use of undeclared type or module `std` when used in a separate module
  28. How do I cope with lazy iterators?
  29. Lazy sequence generation in Rust
  30. Is there a way to get the field names of a struct in a macro?

Leave a Comment