Why does this mutable borrow live beyond its scope?

by

In short, &'a mut Chain<'a> is extremely limiting and pervasive.

For an immutable reference &T<'a>, the compiler is allowed to shorten the lifetime of 'a when necessary to match other lifetimes or as part of NLL (this is not always the case, it depends on what T is). However, it cannot do so for mutable references &mut T<'a>, otherwise you could assign it a value with a shorter lifetime.

So when the compiler tries to reconcile the lifetimes when the reference and the parameter are linked &'a mut T<'a>, the lifetime of the reference is conceptually expanded to match the lifetime of the parameter. Which essentially means you’ve created a mutable borrow that will never be released.

Applying that knowledge to your question: creating a reference-based hierarchy is really only possible if the nested values are covariant over their lifetimes. Which excludes:

  • mutable references
  • trait objects
  • structs with interior mutability

Refer to these variations on the playground to see how these don’t quite work as expected.

See also:

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. Cannot move out of value which is behind a shared reference when unwrapping
  3. Why does refactoring by extracting a method trigger a borrow checker error?
  4. Temporarily move out of borrowed content
  5. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  6. Passing mutable self reference to method of owned object
  7. Mutably borrow one struct field while borrowing another in a closure
  8. Do mutable references have move semantics?
  9. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  10. Double mutable borrow error in a loop happens even with NLL on
  11. What are the options to end a mutable borrow in Rust?
  12. How to update-or-insert on a Vec?
  13. “borrowed value does not live long enough” when using the builder pattern
  14. How to use struct self in member method closure
  15. Can’t borrow mutably within two different closures in the same scope
  16. Temporary value is freed at the end of this statement [duplicate]
  17. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  18. How can I modify self in a closure called from a member function?
  19. How do I move out of a struct field that is an Option?
  20. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  21. Deriving a trait results in unexpected compiler error, but the manual implementation works
  22. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  23. Can I write an Iterator that mutates itself and then yields a reference into itself?
  24. How do I specify lifetime parameters in an associated type?
  25. What is the right way to allocate data to pass to an FFI call?
  26. Is there a way to combine multiple traits in order to define a new trait? [duplicate]
  27. How to avoid temporary allocations when using a complex key for a HashMap?
  28. Why does compilation not fail when a member of a moved value is assigned to?
  29. What does “missing lifetime specifier” mean when storing a &str in a structure?
  30. Comparing every element in a vector with the next one

Leave a Comment