rust - 迭代递归结构时无法获取可变引用 : cannot borrow as mutable more than once at a time

Question

我正在尝试迭代地导航递归数据结构，以便在特定位置插入元素。就我有限的理解而言，这意味着对结构的根进行可变引用，然后用对其跟随者的引用依次替换它:

type Link = Option<Box<Node>>;

struct Node {
    next: Link
}

struct Recursive {
    root: Link
}

impl Recursive {
    fn back(&mut self) -> &mut Link {
        let mut anchor = &mut self.root;
        while let Some(ref mut node) = *anchor {
            anchor = &mut node.next;
        }
        anchor
    }
}

(Rust playground link)

然而，这失败了:

error[E0499]: cannot borrow `anchor.0` as mutable more than once at a time
  --> src/main.rs:14:24
   |
14 |         while let Some(ref mut node) = *anchor {
   |                        ^^^^^^^^^^^^
   |                        |
   |                        second mutable borrow occurs here
   |                        first mutable borrow occurs here
...
18 |     }
   |     - first borrow ends here

error[E0506]: cannot assign to `anchor` because it is borrowed
  --> src/main.rs:15:13
   |
14 |         while let Some(ref mut node) = *anchor {
   |                        ------------ borrow of `anchor` occurs here
15 |             anchor = &mut node.next;
   |             ^^^^^^^^^^^^^^^^^^^^^^^ assignment to borrowed `anchor` occurs here

error[E0499]: cannot borrow `*anchor` as mutable more than once at a time
  --> src/main.rs:17:9
   |
14 |         while let Some(ref mut node) = *anchor {
   |                        ------------ first mutable borrow occurs here
...
17 |         anchor
   |         ^^^^^^ second mutable borrow occurs here
18 |     }
   |     - first borrow ends here

这是有道理的，因为 anchor 和 node 都引用相同的结构，但实际上我不再关心 anchor 之后解构它。

back() 如何使用安全的 Rust 正确实现？

Answer 1

这是可能的......但我希望我有一个更优雅的解决方案。

诀窍不是从 anchor 借用，因此要在两个累加器之间兼顾:

• 一个持有对当前节点的引用
• 另一个被分配到下一个节点的引用

这导致我:

impl Recursive {
    fn back(&mut self) -> &mut Link {
        let mut anchor = &mut self.root;

        loop {
            let tmp = anchor;
            if let Some(ref mut node) = *tmp {
                anchor = &mut node.next;
            } else {
                anchor = tmp;
                break;
            }
        }

        anchor
    }
}

不是很漂亮，但这是借用检查器可以解决的问题，所以¯\_(ツ)_/¯。

@ker 通过创建一个未命名的临时文件对此进行了改进:

impl Recursive {
    fn back(&mut self) -> &mut Link {
        let mut anchor = &mut self.root;

        loop {
            match {anchor} {
                &mut Some(ref mut node) => anchor = &mut node.next,
                other => return other,
            }
        }
    }
}

这里的技巧是使用 {anchor} 移动 anchor 的内容到匹配执行的未命名的临时文件中。因此，在 match block 中，我们不是从 anchor 借用，而是从临时借用，让我们可以自由修改 anchor。请参阅相关博文 Stuff the Identity Function Does (in Rust) .