递归场景下访问可变缓存的Rust借用检查器问题求解

你的代码触发借用检查错误的核心原因是：当通过cache.get(value)获取到缓存值的不可变引用后，Rust不允许再获取cache的可变引用——因为理论上可变引用可以修改或删除你正在使用的缓存项，导致悬空引用。而你实际只插入新值、不修改已有项的逻辑，借用检查器无法自动识别。

以下是几种无需克隆整个Vec<String>的解决方案：

方案一：用Rc轻量包裹缓存值（推荐） #

将缓存的值类型改为Rc<Vec<String>>，利用Rc的引用计数特性，克隆Rc仅需复制指针和增加计数（开销极低），以此释放对原缓存的不可变借用，安全传递可变引用给递归调用。

use std::collections::HashMap;
use std::rc::Rc;

fn foo(value: &String, cache: &mut HashMap<String, Rc<Vec<String>>>) {
    // 插入新值时用Rc包裹，避免重复插入
    cache.entry("a".to_string())
        .or_insert_with(|| Rc::new(vec!["b".to_string()]));
    
    // 克隆Rc，释放对cache的不可变借用
    if let Some(cached_result) = cache.get(value).cloned() {
        cached_result
            .iter()
            .for_each(|cached_value| foo(cached_value, cache));
    }
}

方案二：使用unsafe代码（不推荐） #

通过裸指针绕过借用检查器，但需要手动保证递归期间不会修改/删除正在使用的缓存项，否则会导致未定义行为。仅在无法使用其他安全方案时考虑。

use std::collections::HashMap;

fn foo(value: &String, cache: &mut HashMap<String, Vec<String>>) {
    cache.insert("a".to_string(), vec!["b".to_string()]);
    
    let cached_result = cache.get(value);
    if let Some(cached_result) = cached_result {
        // 将缓存值转为裸指针和长度，构造slice
        let ptr = cached_result.as_ptr();
        let len = cached_result.len();
        let slice = unsafe { std::slice::from_raw_parts(ptr, len) };
        
        // 此时原缓存的不可变借用已释放，可安全传递可变引用
        slice
            .iter()
            .for_each(|cached_value| foo(cached_value, cache));
    }
}

方案三：提前收集递归依赖（仅适用于特定场景） #

如果缓存项的数量较少，可以先将需要递归的所有值的引用收集到临时变量中，再释放对缓存的不可变借用，之后进行递归调用。但这种方法需要克隆字符串（而非整个Vec），如果字符串本身很大，开销依然存在：

use std::collections::HashMap;

fn foo(value: &String, cache: &mut HashMap<String, Vec<String>>) {
    cache.insert("a".to_string(), vec!["b".to_string()]);
    
    // 提前收集需要递归的字符串克隆
    let to_recurse: Vec<String> = cache.get(value)
        .map(|v| v.iter().cloned().collect())
        .unwrap_or_default();
    
    // 此时缓存的不可变借用已释放，可传递可变引用
    to_recurse
        .iter()
        .for_each(|cached_value| foo(cached_value, cache));
}

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