How can I borrow from a HashMap to read and write at the same time?

by

TL;DR: You will need to change the type of HashMap

When using a method, the compiler does not inspect the interior of a method, or perform any runtime simulation: it only bases its ownership/borrow-checking analysis on the signature of the method.

In your case, this means that:

  • using get will borrow the entire HashMap for as long as the reference lives,
  • using get_mut will mutably borrow the entire HashMap for as long as the reference lives.

And therefore, it is not possible with a HashMap<K, V> to obtain both a &V and &mut V at the same time.

The work-around, therefore, is to avoid the need for a &mut V entirely.

This can be accomplished by using Cell or RefCell:

  • Turn your HashMap into HashMap<K, RefCell<V>>,
  • Use get in both cases,
  • Use borrow() to get a reference and borrow_mut() to get a mutable reference.
use std::{cell::RefCell, collections::HashMap};

fn main() {
    let mut map = HashMap::new();

    map.insert("1", RefCell::new(1));
    map.insert("2", RefCell::new(2));

    {
        let a = map.get("1").unwrap();
        println!("a: {}", a.borrow());

        let b = map.get("2").unwrap();
        println!("b: {}", b.borrow());
        *b.borrow_mut() = 5;
    }

    println!("Results: {:?}", map);
}

This will add a runtime check each time you call borrow() or borrow_mut(), and will panic if you ever attempt to use them incorrectly (if the two keys are equal, unlike your expectations).

As for using fields: this works because the compiler can reason about borrowing status on a per-field basis.

More Related Contents:

  1. How do I create a heterogeneous collection of objects?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. Is it possible to control the size of an array using the type parameter of a generic?
  4. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  5. Are polymorphic variables allowed?
  6. Does println! borrow or own the variable?
  7. How do I pass disjoint slices from a vector to different threads?
  8. Efficiently mutate a vector while also iterating over the same vector
  9. Why is it possible to implement Read on an immutable reference to File?
  10. Compare enums only by variant, not value
  11. How can I call a mutating method while holding a reference to self?
  12. How do you actually use dynamically sized types in Rust?
  13. Why do I need rebinding/shadowing when I can have mutable variable binding?
  14. “parameter `’a` is never used” error when ‘a is used in type parameter bound
  15. Borrowing references to attributes in a struct
  16. How can I put an async function into a map in Rust?
  17. How to operate on 2 mutable slices of a Rust array?
  18. Mutating one field while iterating over another immutable field
  19. How can I use a module from outside the src folder in a binary project, such as for integration tests or benchmarks?
  20. How to match on data type in Rust?
  21. Why does Rust allow mutation through a reference field using an immutable binding?
  22. Multiple return types from a method
  23. How to end a borrow in a match or if let expression?
  24. How do I synchronously return a value calculated in an asynchronous Future?
  25. Why does this mutable borrow live beyond its scope?
  26. Why does creating a mutable reference to a dereferenced mutable reference work?
  27. Cannot borrow `x` as mutable more than once at a time
  28. Removing elements from a Vec based on some condition [duplicate]
  29. What’s the difference between using the return statement and omitting the semicolon in Rust?
  30. The trait `FnMut` is not implemented for `String` when trying to split a string

Leave a Comment