rust - 不能在一个代码中一次多次借用可变的 - 但可以在另一个非常相似的代码中

Question

我的这个片段没有通过借用检查器:

use std::collections::HashMap;

enum Error {
    FunctionNotFound,
}

#[derive(Copy, Clone)]
struct Function<'a> {
    name: &'a str,
    code: &'a [u32],
}

struct Context<'a> {
    program: HashMap<&'a str, Function<'a>>,
    call_stack: Vec<Function<'a>>,
}

impl<'a> Context<'a> {
    fn get_function(&'a mut self, fun_name: &'a str) -> Result<Function<'a>, Error> {
        self.program
            .get(fun_name)
            .map(|f| *f)
            .ok_or(Error::FunctionNotFound)
    }

    fn call(&'a mut self, fun_name: &'a str) -> Result<(), Error> {
        let fun = try!(self.get_function(fun_name));

        self.call_stack.push(fun);

        Ok(())
    }
}

fn main() {}

error[E0499]: cannot borrow `self.call_stack` as mutable more than once at a time
  --> src/main.rs:29:9
   |
27 |         let fun = try!(self.get_function(fun_name));
   |                        ---- first mutable borrow occurs here
28 | 
29 |         self.call_stack.push(fun);
   |         ^^^^^^^^^^^^^^^ second mutable borrow occurs here
...
32 |     }
   |     - first borrow ends here

我的直觉是问题与 HashMap 返回 None 或数据结构中值的引用这一事实有关。但我不希望这样:我的意图是 self.get_function 应该返回存储值的字节副本或错误(这就是为什么我把 .map(|f| * f), Function 为Copy).

将 &'a mut self 更改为其他内容无济于事。

但是，下面的代码片段在本质上有些相似，但被接受:

#[derive(Debug)]
enum Error {
    StackUnderflow,
}

struct Context {
    stack: Vec<u32>,
}

impl Context {
    fn pop(&mut self) -> Result<u32, Error> {
        self.stack.pop().ok_or(Error::StackUnderflow)
    }

    fn add(&mut self) -> Result<(), Error> {
        let a = try!(self.pop());
        let b = try!(self.pop());

        self.stack.push(a + b);
        Ok(())
    }
}

fn main() {
    let mut a = Context { stack: vec![1, 2] };
    a.add().unwrap();
    println!("{:?}", a.stack);
}

现在我很困惑。第一个片段有什么问题？为什么不在第二个发生？

这些片段是一段较大代码的一部分。为了提供更多上下文，this on the Rust Playground显示了一个更完整的错误代码示例，this shows an earlier version without HashMap ，它通过了借用检查器并正常运行。

Answer 1

你掉进了人生陷阱。将相同的生命周期添加到更多引用将更多地限制您的程序。添加更多的生命周期并为每个引用提供尽可能短的生命周期将允许更多的程序。正如@o11c 指出的那样，删除对 'a 生命周期的约束将解决您的问题。

impl<'a> Context<'a> {
    fn get_function(&mut self, fun_name: &str) -> Result<Function<'a>, Error> {
        self.program
            .get(fun_name)
            .map(|f| *f)
            .ok_or(Error::FunctionNotFound)
    }

    fn call(&mut self, fun_name: &str) -> Result<(), Error> {
        let fun = try!(self.get_function(fun_name));

        self.call_stack.push(fun);

        Ok(())
    }
}

之所以可行，是因为 Rust 插入了新的生命周期，因此在编译器中，您的函数签名将如下所示:

fn get_function<'b>(&'b mut self, fun_name: &'b str) -> Result<Function<'a>, Error>
fn call<'b>(&'b mut self, fun_name: &'b str) -> Result<(), Error>

始终尽量不使用任何生命周期，让编译器变得聪明。如果失败了，不要到处喷生命周期，想想你想在什么地方传递所有权，以及你想在什么地方限制引用的生命周期。