一次不能多次借用“x”作为可变变量

Question

在以下代码中（playground）：

struct Node {
    datum: &'static str,
    edges: Vec<Node>,
}

fn add<'a>(node: &'a mut Node, data: &'static str) -> &'a Node {
    node.edges.push(Node {
        datum: data,
        edges: Vec::new(),
    });
    &node.edges[node.edges.len() - 1] // return just added one
}

fn traverse<F>(root: &Node, callback: &F)
where
    F: Fn(&'static str),
{
    callback(root.datum);
    for node in &root.edges {
        traverse(node, callback);
    }
}

fn main() {
    let mut tree = Node {
        datum: "start",
        edges: Vec::new(),
    };

    let lvl1 = add(&mut tree, "level1");

    traverse(&mut tree, &|x| println!("{:}", x)); //I actually don't need mutability here
}

我有这个错误：

error[E0499]: cannot borrow `tree` as mutable more than once at a time
  --> src/main.rs:32:19
   |
30 |     let lvl1 = add(&mut tree, "level1");
   |                         ---- first mutable borrow occurs here
31 | 
32 |     traverse(&mut tree, &|x| println!("{:}", x)); //I actually don't need mutability here
   |                   ^^^^ second mutable borrow occurs here
33 | }
   | - first borrow ends here

我的问题似乎与Why does Rust want to borrow a variable as mutable more than once at a time? 非常相似，但我不确定。如果是这样，这种情况是否有解决方法？

Answer 1

这是因为add 的定义方式：

fn add<'a>(node: &'a mut Node, data: &'static str) -> &'a Node

这里指定结果引用的生命周期应该等于传入引用的生命周期。 唯一可能的方式（不安全代码除外）是结果引用以某种方式从传入引用派生，例如，它引用传入引用指向的对象内部的某些字段：

struct X {
    a: u32,
    b: u32,
}

fn borrow_a<'a>(x: &'a mut X) -> &'a mut u32 {
    &mut x.a
}

但是，编译器没有方法可以通过仅查看函数签名（通常是编译使用此函数的代码时唯一可以做的事情）。因此，它无法知道以下代码在技术上是正确的：

let mut x = X { a: 1, b: 2 };
let a = borrow_a(&mut x);
let b = &mut x.b;

我们知道a 和b 是不相交的，因为它们指向结构的不同部分，但编译器无法知道这一点，因为borrow_a 中没有任何内容建议的签名（不可能，Rust 不支持它）。

因此，编译器唯一明智的做法是考虑整个 x 被借用，直到borrow_a() 返回的引用被删除。否则可能会为相同的数据创建两个可变引用，这违反了 Rust 别名保证。

注意以下代码是正确的：

let mut x = X { a: 1, b: 2 };
let a = &mut x.a;
let b = &mut x.b;

这里编译器可以看到a和b从不指向同一个数据，即使它们指向同一个结构内部。

对此没有解决方法，唯一的解决方案是重组代码，使其不具有此类借用模式。

Answer 2

这种行为是合乎逻辑的。考虑什么

fn add<'a>(node: &'a mut Node, data: &'static str) -> &'a Node

意思。

这表示&mut Node 的生命周期等于其返回值的生命周期。因为您将返回值分配给一个名称，所以它会一直存在到作用域的末尾。因此，可变借用也存在那么久。

如果您可以轻松丢弃返回值，请这样做。你可以把它扔在地板上：

let mut tree = Node {
    datum: "start",
    edges: Vec::new(),
};

add(&mut tree, "level1");

traverse(&mut tree, &|x| println!("{:}", x));

或者您可以使用词法范围来限制它而不完全删除它。

如果你想借用 return 而不强制可变借用也能活那么久，你可能不得不将函数一分为二。这是因为您无法从可变借用中借用返回值。