Cannot borrow as mutable because it is also borrowed as immutable

by

A MRE of your problem can be reduced to this:

// This applies to the version of Rust this question
// was asked about; see below for updated examples.
fn main() {
    let mut items = vec![1];
    let item = items.last();
    items.push(2);
}

error[E0502]: cannot borrow `items` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let item = items.last();
  |                ----- immutable borrow occurs here
4 |     items.push(2);
  |     ^^^^^ mutable borrow occurs here
5 | }
  | - immutable borrow ends here

You are encountering the exact problem that Rust was designed to prevent. You have a reference pointing into the vector and are attempting to insert into the vector. Doing so might require that the memory of the vector be reallocated, invalidating any existing references. If that happened and you used the value in item, you’d be accessing uninitialized memory, potentially causing a crash.

In this particular case, you aren’t actually using item (or source, in the original) so you could just… not call that line. I assume you did that for some reason, so you could wrap the references in a block so that they go away before you try to mutate the value again:

fn main() {
    let mut items = vec![1];
    {
        let item = items.last();
    }
    items.push(2);
}

This trick is no longer needed in modern Rust because non-lexical lifetimes have been implemented, but the underlying restriction still remains — you cannot have a mutable reference while there are other references to the same thing. This is one of the rules of references covered in The Rust Programming Language. A modified example that still does not work with NLL:

let mut items = vec![1];
let item = items.last();
items.push(2);
println!("{:?}", item);

In other cases, you can copy or clone the value in the vector. The item will no longer be a reference and you can modify the vector as you see fit:

fn main() {
    let mut items = vec![1];
    let item = items.last().cloned();
    items.push(2);
}

If your type isn’t cloneable, you can transform it into a reference-counted value (such as Rc or Arc) which can then be cloned. You may or may not also need to use interior mutability:

struct NonClone;

use std::rc::Rc;

fn main() {
    let mut items = vec![Rc::new(NonClone)];
    let item = items.last().cloned();
    items.push(Rc::new(NonClone));
}

this example from Programming Rust is quite similar

No, it’s not, seeing as how it doesn’t use references at all.

See also

More Related Contents:

  1. Is there any way to return a reference to a variable created in a function?
  2. Why can I return a reference to a local literal but not a variable?
  3. Cannot move out of borrowed content / cannot move out of behind a shared reference
  4. Why are explicit lifetimes needed in Rust?
  5. How do I implement the Add trait for a reference to a struct?
  6. Cannot move out of borrowed content when trying to transfer ownership
  7. How to avoid writing duplicate accessor functions for mutable and immutable references in Rust?
  8. Iterator returning items by reference, lifetime issue
  9. Why does pattern matching on &Option yield something of type Some(&T)?
  10. What is the purpose of `&` before the loop variable?
  11. Why is “&&” being used in closure arguments?
  12. When should I not implement a trait for references to implementors of that trait?
  13. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  14. How to abstract over a reference to a value or a value itself?
  15. Rust lifetime error expected concrete lifetime but found bound lifetime
  16. Why can’t I store a value and a reference to that value in the same struct?
  17. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  18. How can I pass a reference to a stack variable to a thread?
  19. What are Rust’s exact auto-dereferencing rules?
  20. What’s the difference between placing “mut” before a variable name and after the “:”?
  21. Why does linking lifetimes matter only with mutable references?
  22. Why is the return type of Deref::deref itself a reference?
  23. Convert Vec into a slice of &str in Rust?
  24. What lifetimes do I use to create Rust structs that reference each other cyclically?
  25. How to query mongodb with DBRef
  26. Finding all references of a variable or a method in Xcode4
  27. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  28. Pass by reference problem with PHP 5.3.1 [duplicate]
  29. What is the difference between a C# Reference and a Pointer?
  30. Why does Rust not implement total ordering via the Ord trait for f64 and f32?

Leave a Comment