使用参考枢轴循环时出现可变借用问题

Question

struct A {
    next: Option<Box<A>>,
}

impl A {
    fn grow(&mut self) {
        self.next = Some(Box::new(A { next: None }));
    }
}

fn main() {
    let mut a = A{ next: Some(Box::new(A { next: None }))};
    let mut p = &mut a;
    // attempt to append to the list
    loop {
        match &mut p.next {
            Some(n) => p = n,
            None => {
                p.grow();
                break;
            }
        }
    }
}

上面的代码是一个更复杂的数据结构的简化逻辑，能够重现借用检查器投诉：

error[E0499]: cannot borrow `*p` as mutable more than once at a time
  --> t.rs:19:17
   |
16 |         match &mut p.next {
   |               ----------- first mutable borrow occurs here
...
19 |                 p.grow();
   |                 ^
   |                 |
   |                 second mutable borrow occurs here
   |                 first borrow later used here

error: aborting due to previous error

为什么在 match case 中仍然认为 p 是可变借用的？ 而且，试图将p.update() 移出循环也无济于事：

fn main() {
    let mut a = A{ next: Some(Box::new(A { next: None }))};
    let mut p = &mut a;
    // attempt to append to the list
    loop {
        match &mut p.next {
            Some(n) => p = n,
            None => {
                break;
            }
        }
    }
    p.grow();
}

在这种情况下，我遇到了同样的错误。我知道p = n 导致了这个问题，因为它在没有它的情况下编译通过，但是为什么呢？

Answer 1

这是我对正在发生的事情的看法。为了解释它，我在不改变想法的情况下稍微简化了您的代码：

fn main() {
    let mut a = A{ next: Some(Box::new(A { next: None }))};
    let mut p = &mut a;
    let next = &mut p.next;
    if let Some(n) = next {
        p = n;
    }

    p.grow();
}

此代码产生与您相同的错误。更有趣的是，你不能在main 的末尾以任何方式使用p。即使println!("{:?}", p) 也会产生同样的错误。

编译器检查代码可以执行的所有方式，并发现在调用p.grow() 时，p 可以指向a，也可以指向a.next.as_mut()（我的意思是@987654330 的内部值@ 选项结构）。但是p.grow() 需要使用其中一个引用。

如果p == &mut a，我们调用p.grow()，那么对a.next.as_mut() 的引用就会失效，从而出错。如果p == a.next.as_mut()，我们调用p.grow()，我们引用&mut a两次，因为第一个借用仍然不能被删除。

如果不分配p = n，则不存在这样的问题，因为只有一个有效引用，编译器可以在调用p.grow()时使用。

在这个例子中实际上有 3 种方法可以防止编译器错误：

1. 删除p = n 分配。
2. 将 p.grow() 移动到 if let 块内，从而确保在调用时 p 引用内部值。
3. 退出 main 以防 next 是 Some：

if let Some(n) = next {
  p = n;
} else {
  return;
}

p.grow();

后一种方法是可行的，因为编译器确定在p.grow() 调用处首先借用不需要并且可以删除，而p 只能指向内部值。

原始问题中的问题是相同的。编译器必须确定 p 在调用 p.grow() 时引用的内容。

在Lagerbaer提供的解决方案中，p在调用p.grow()时只能引用一个特定的值（此时没有引用p.next），这样就可以了：

    let mut p = &mut a;
    // attempt to append to the list
    loop {
        match p.next {
            Some(ref mut n) => p = n,
            None => {
                p.grow();
                break;
            }
        }
    }

Answer 2

为什么要在匹配表达式中借用？那是不必要的。只需匹配p.next。这本身并没有移动。移动的是您匹配的模式类型。那么我们匹配Some(ref mut n)，而不是匹配Some(n)。

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=1859dc15cdc08ddec8cac3efb6d8fa31