带生命周期'a的结构体在for循环中无法可变借用的原因及解决方案

我定义了一个用于映射ID与索引的双向映射结构体IdMapping<'a>，代码如下：

use std::collections::HashMap;

struct IdMapping<'a> {
    external_2_internal: HashMap<&'a str, usize>,
    internal_2_external: HashMap<usize, String>,
}

impl<'a> IdMapping<'a> {
    fn new() -> IdMapping<'a> {
        IdMapping {
            external_2_internal: HashMap::new(),
            internal_2_external: HashMap::new(),
        }
    }

    fn insert(&'a mut self, internal: usize, external: String) {
        self.internal_2_external.insert(internal, external);
        let mapped_external = self.internal_2_external.get(&internal).unwrap();
        self.external_2_internal.insert(mapped_external, internal);
    }
}

当我通过以下方式使用该结构体时：

fn map_ids<'a>(ids: Vec<String>) -> IdMapping<'a> {
    let mut mapping = IdMapping::new();

    for (i, id) in ids.iter().enumerate() {
        mapping.insert(i, id.clone());
    }

    mapping
}

编译器抛出错误：

error[E0499]: cannot borrow `mapping` as mutable more than once at a time
  --> src/lib.rs:28:9
   |
24 | fn map_ids<'a>(ids: Vec<String>) -> IdMapping<'a> {
   |            -- lifetime `'a` defined here
...
28 |         mapping.insert(i, id.clone());
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `mapping` was mutably borrowed here in the previous iteration of the loop
...
31 |     mapping
   |     ------- returning this value requires that `mapping` is borrowed for `'a`

错误原因分析 #

核心问题出在insert方法的签名上：fn insert(&'a mut self, internal: usize, external: String)。这里把&mut self的生命周期强行绑定到了结构体的'a生命周期上，意味着第一次调用insert后，mapping的可变借用会持续到整个'a周期结束——也就是函数返回mapping的时候。

而Rust的借用规则明确禁止同一时间存在多个可变借用，所以循环第二次迭代尝试再次可变借用mapping时，就会触发编译错误。

另外，虽然external_2_internal存储的引用指向同结构体中internal_2_external的String本身是安全的，但方法签名的错误生命周期绑定放大了这个问题。

解决方案 #

方案一：修正生命周期绑定（推荐，无额外内存开销） #

移除insert方法中&mut self的'a生命周期绑定，让Rust自动推导匿名生命周期，同时优化值的获取逻辑：

use std::collections::HashMap;

struct IdMapping<'a> {
    external_2_internal: HashMap<&'a str, usize>,
    internal_2_external: HashMap<usize, String>,
}

impl<'a> IdMapping<'a> {
    fn new() -> IdMapping<'a> {
        IdMapping {
            external_2_internal: HashMap::new(),
            internal_2_external: HashMap::new(),
        }
    }

    // 移除&mut self上的'a绑定，使用Rust自动推导的匿名生命周期
    fn insert(&mut self, internal: usize, external: String) {
        // 利用insert的返回值直接拿到插入的String引用，避免二次查询
        let external_ref = self.internal_2_external.insert(internal, external)
            .unwrap_or_else(|| panic!("Internal index {} already exists", internal));
        self.external_2_internal.insert(external_ref.as_str(), internal);
    }
}

fn map_ids(ids: Vec<String>) -> IdMapping<'_> {
    let mut mapping = IdMapping::new();

    // 使用into_iter转移所有权，避免不必要的clone
    for (i, id) in ids.into_iter().enumerate() {
        mapping.insert(i, id);
    }

    mapping
}

方案二：移除生命周期（简单直观，少量内存开销） #

如果可以接受少量内存重复存储，直接把external_2_internal改成存储String，彻底规避生命周期问题：

use std::collections::HashMap;

struct IdMapping {
    external_2_internal: HashMap<String, usize>,
    internal_2_external: HashMap<usize, String>,
}

impl IdMapping {
    fn new() -> IdMapping {
        IdMapping {
            external_2_internal: HashMap::new(),
            internal_2_external: HashMap::new(),
        }
    }

    fn insert(&mut self, internal: usize, external: String) {
        self.internal_2_external.insert(internal, external.clone());
        self.external_2_internal.insert(external, internal);
    }
}

fn map_ids(ids: Vec<String>) -> IdMapping {
    let mut mapping = IdMapping::new();

    for (i, id) in ids.into_iter().enumerate() {
        mapping.insert(i, id);
    }

    mapping
}

内容的提问来源于stack exchange，提问作者Janek