How can I mutate other elements of a HashMap when using the entry pattern?

by

hellow has shown how to get working code, but I want to dive a bit more into why your code does not compile.

The code you have proposed cannot be statically verified to be memory safe. It’s entirely possible that your recursive calls attempt to access the same index. Check out this simplified code for one possibility:

use std::collections::{hash_map::Entry, HashMap};

fn compute(cache: &mut HashMap<u32, u32>) {
    if let Entry::Vacant(_entry) = cache.entry(42) {
        let _aliased_mutable_reference = cache.get_mut(&42).unwrap();
    }
}

This now has two mutable references pointing to the same value, violating the rules of references.

Additionally, what if the inner call used entry and it didn’t exist?

use std::collections::{hash_map::Entry, HashMap};

fn compute(cache: &mut HashMap<u32, u32>) {
    if let Entry::Vacant(entry1) = cache.entry(42) {
        if let Entry::Vacant(entry2) = cache.entry(41) {
            entry2.insert(2);
            entry1.insert(1);
        }
    }
}

Now, when you insert the value into the map via entry2, the map may reallocate the underlying memory, invalidating the reference held by entry1, violating the other rule of references.

Rust has prevented you from introducing two possible types of memory unsafety into your program; just like it was designed to do.

More Related Contents:

  1. How to lookup from and insert into a HashMap efficiently?
  2. How to implement HashMap with two keys?
  3. How do I create a HashMap literal?
  4. How can I update a value in a mutable HashMap?
  5. How to iterate through a Hashmap, print the key/value and remove the value in Rust?
  6. Is it possible to use a HashSet as the key to a HashMap?
  7. Why can’t I store a value and a reference to that value in the same struct?
  8. Why can I return a reference to a local literal but not a variable?
  9. Cannot move out of borrowed content / cannot move out of behind a shared reference
  10. Cannot move out of value which is behind a shared reference when unwrapping
  11. Why does refactoring by extracting a method trigger a borrow checker error?
  12. Temporarily move out of borrowed content
  13. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  14. Do mutable references have move semantics?
  15. Double mutable borrow error in a loop happens even with NLL on
  16. What are the options to end a mutable borrow in Rust?
  17. Cannot move out of borrowed content when trying to transfer ownership
  18. “borrowed value does not live long enough” when using the builder pattern
  19. How to use struct self in member method closure
  20. How do I use the Entry API with an expensive key that is only constructed if the Entry is Vacant?
  21. Can’t borrow mutably within two different closures in the same scope
  22. Why is “&&” being used in closure arguments?
  23. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  24. How can I modify self in a closure called from a member function?
  25. How do I move out of a struct field that is an Option?
  26. Why does this mutable borrow live beyond its scope?
  27. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  28. How can I use a HashMap with f64 as key in Rust?
  29. How can I do a mutable borrow in a for loop?
  30. How do I create a HashMap with type erased keys?

Leave a Comment