如何在 Rust 中修复“.. 在循环的上一次迭代中可变地借用”？

Question

我必须对键进行迭代，通过键在 HashMap 中找到值，可能在找到的结构中作为值进行一些繁重的计算（惰性 => 改变结构）并将其缓存在 Rust 中返回。

我收到以下错误消息：

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/main.rs:25:26
   |
23 |     fn it(&mut self) -> Option<&Box<Calculation>> {
   |           - let's call the lifetime of this reference `'1`
24 |         for key in vec!["1","2","3"] {
25 |             let result = self.find(&key.to_owned());
   |                          ^^^^ `*self` was mutably borrowed here in the previous iteration of the loop
...
28 |                 return result
   |                        ------ returning this value requires that `*self` is borrowed for `'1`

这里是code in playground。

use std::collections::HashMap;

struct Calculation {
    value: Option<i32>
}

struct Struct {
    items: HashMap<String, Box<Calculation>> // cache
}

impl Struct {
    fn find(&mut self, key: &String) -> Option<&Box<Calculation>> {
        None // find, create, and/or calculate items
    }

    fn it(&mut self) -> Option<&Box<Calculation>> {
        for key in vec!["1","2","3"] {
            let result = self.find(&key.to_owned());
            if result.is_some() {
                return result
            }
        }
        None
    }
}

• 我无法避免循环，因为我必须检查多个键
• 我必须让它可变（self 和结构），因为可能的计算会改变它

关于如何改变设计（因为 Rust 迫使以一种有意义的不同方式思考）或解决它的任何建议？

PS。代码还有一些其他的问题，但让我们先拆分问题并解决这个问题。

Answer 1

您不能使用 独占 访问权限进行缓存。您不能将 Rust 引用视为通用指针（顺便说一句：&String 和 &Box<T> 是双重间接，并且在 Rust 中非常单一。使用 &str 或 &T 进行临时借用）。

&mut self 不仅意味着可变，而且独占和可变，因此您的缓存支持仅返回一项，因为它返回的引用必须保持self“锁定”只要它存在。

你需要让借用检查器相信 find 返回的东西不会在你下次调用它时突然消失。目前没有这样的保证，因为接口不会阻止你调用例如items.clear()（借用检查器检查函数的接口允许什么，而不是函数实际执行什么）。

您可以通过使用Rc 或使用实现a memory pool/arena 的板条箱来做到这一点。

struct Struct {
   items: HashMap<String, Rc<Calculation>>,
}

fn find(&mut self, key: &str) -> Rc<Calculation> 

这样，如果您克隆 Rc，它会在需要的时间内存活，与缓存无关。

您还可以通过内部可变性使其更好。

struct Struct {
   items: RefCell<HashMap<…
}

这将允许您的记忆 find 方法使用共享借用而不是独占借用：

fn find(&self, key: &str) -> …

这对于方法的调用者来说更容易使用。

Answer 2

可能不是最干净的方法，但它可以编译。我们的想法是不要将找到的值存储在临时结果中，以避免出现别名：如果存储结果，self 会一直被借用。

impl Struct {

    fn find(&mut self, key: &String) -> Option<&Box<Calculation>> {
        None
    }

    fn it(&mut self) -> Option<&Box<Calculation>> {
        for key in vec!["1","2","3"] {
            if self.find(&key.to_owned()).is_some() {
                return self.find(&key.to_owned());
            }
        }
        None
    }
}