Why do Rust lifetimes break mutable references in loops?

In attempting to refactor a Rust application that was working fine, I tried to separate out the contents of a loop into a new function. However, in this newly refactored out function, I needed to pass an argument that had to be mutable, and passed by reference. Suddenly the code that absolutely worked inline, broke just because of the mutable reference passing.

My question is: can someone please explain why this does not work with such a "simple" change? (i.e. refactoring out a new function of otherwise unchanged code)

I have a minimal demo of the problem, along with a couple of working comparisons below. Here is the error from that code:

error[E0499]: cannot borrow `str_to_int` as mutable more than once at a time
  --> src/main.rs:30:22
   |
30 |         get_key(key, &mut str_to_int);
   |                      ^^^^^^^^^^^^^^^ `str_to_int` was mutably borrowed here in the previous iteration of the loop

The sample code:

use std::collections::BTreeMap;

fn get_int (
    key: u32,
    values: &mut BTreeMap<u32, u32>,
) -> &u32 {
    values.entry(key).or_insert_with(|| { 1 })
}

fn get_key<'a> (
    key: &'a str,
    values: &'a mut BTreeMap<&'a str, u32>,
) -> &'a u32 {
    values.entry(key).or_insert_with(|| { 1 })
}

fn main() {
    let mut int_to_int = BTreeMap::new();
    for key in vec![1,2] {
        get_int(key, &mut int_to_int);
    }

    let mut str_to_int_inline = BTreeMap::new();
    for key in vec!["a","b"] {
        str_to_int_inline.entry(key).or_insert_with(|| { 1 });
    }

    let mut str_to_int = BTreeMap::new();
    for key in vec!["a","b"] {
        get_key(key, &mut str_to_int);
    }
}

Note that the first loop (int_to_int) is identical to the third loop (str_to_int) except for the data type of the key -- in that the key was not a reference, so no lifetime was required to be specified. And the second loop (str_to_int_inline) is identical to the third loop (str_to_int) except the behavior is inline instead of in a separate function.

There are many related questions and blogs on this topic, but they all seem more specifically focused on particular versions of this question, and I want to know the more generic explanation (to my current understanding). If the answer is already just to understand one of these links better, I will gladly mark this question as a duplicate.

Related questions:

Something that I read also led me to https://github.com/rust-lang/polonius which also seemed like maybe it could make this work, in the future -- any thoughts?

Solution

Your problem is very simple: you are specifying the lifetimes for get_key() incorrectly.

The correct (and working) version is:

fn get_key<'a, 'b>(key: &'a str, values: &'b mut BTreeMap<&'a str, u32>) -> &'b u32 {
    values.entry(key).or_insert_with(|| 1)
}

Maybe you can already guess what's going on.

Since you used 'a for both the HashMap itself and its keys, it means you were required to borrow the HashMap for as long as the keys' lifetime - 'static. This means two things:

You need a &'static mut HashMap, which you don't have.
You're borrowing the HashMap for 'static in the first iteration of the loop, then borrow it again in the next, while it is still borrowed (because it is borrowed for 'static). This error hides the first error, somewhat erroneously, and is the only error the compiler emits.

In general, using a lifetime twice with a mutable reference is almost always wrong (shared references are more tolerant, as they're covariant over their type).