来自结构 Hashmap 的多个可变借用

Question

Running into an ownership issue when attempting to reference multiple values from a HashMap in a struct as parameters in a function call. Here is a PoC of the issue.

use std::collections::HashMap;

struct Resource {
    map: HashMap<String, String>,
}

impl Resource {
    pub fn new() -> Self {
        Resource {
            map: HashMap::new(),
        }
    }

    pub fn load(&mut self, key: String) -> &mut String {
        self.map.get_mut(&key).unwrap()
    }
}

fn main() {
    // Initialize struct containing a HashMap.
    let mut res = Resource {
        map: HashMap::new(),
    };
    res.map.insert("Item1".to_string(), "Value1".to_string());
    res.map.insert("Item2".to_string(), "Value2".to_string());

    // This compiles and runs.
    let mut value1 = res.load("Item1".to_string());
    single_parameter(value1);
    let mut value2 = res.load("Item2".to_string());
    single_parameter(value2);

    // This has ownership issues.
    // multi_parameter(value1, value2);
}

fn single_parameter(value: &String) {
    println!("{}", *value);
}

fn multi_parameter(value1: &mut String, value2: &mut String) {
    println!("{}", *value1);
    println!("{}", *value2);
}

Uncommenting multi_parameter results in the following error:

28 |     let mut value1 = res.load("Item1".to_string());
   |                      --- first mutable borrow occurs here
29 |     single_parameter(value1);
30 |     let mut value2 = res.load("Item2".to_string());
   |                      ^^^ second mutable borrow occurs here
...
34 |     multi_parameter(value1, value2);
   |                     ------ first borrow later used here

It would technically be possible for me to break up the function calls (using the single_parameter function approach), but it would be more convenient to pass the variables to a single function call.

For additional context, the actual program where I'm encountering this issue is an SDL2 game where I'm attempting to pass multiple textures into a single function call to be drawn, where the texture data may be modified within the function.

Answer 1

This is currently not possible, without resorting to unsafe code or interior mutability at least. There is no way for the compiler to know if two calls to load will yield mutable references to different data as it cannot always infer the value of the key . In theory, mutably borrowing both res.map["Item1"] and res.map["Item2"] would be fine as they would refer to different values in the map, but there is no way for the compiler to know this at compile time.

The easiest way to do this, as already mentioned, is to use a structure that allows interior mutability, like RefCell , which typically enforces the memory safety rules at run-time before returning a borrow of the wrapped value. You can also work around the borrow checker in this case by dealing with mut pointers in unsafe code:

pub fn load_many<'a, const N: usize>(&'a mut self, keys: [&str; N]) -> [&'a mut String; N] {
    // TODO: Assert that keys are distinct, so that we don't return
    // multiple references to the same value

    keys.map(|key| self.load(key) as *mut _)
        .map(|ptr| unsafe { &mut *ptr })
}

Rust Playground

The TODO is important, as this assertion is the only way to ensure that the safety invariant of only having one mutable reference to any value at any time is upheld.

It is, however, almost always better (and easier) to use a known safe interior mutation abstraction like RefCell rather than writing your own unsafe code.