我正在尝试迭代地导航递归数据结构,以便在特定位置插入元素。根据我的有限理解,这意味着对结构的根进行可变引用,并通过对其跟随者的引用连续替换它:
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
}
}
然而,这失败了:
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
。
如何使用安全的Rust正确实现back()
?
答案 0 :(得分:19)
有可能......但我希望我有一个更优雅的解决方案。
诀窍不是从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}
将<{1}}的内容移动到一个未命名的临时执行匹配的临时文件。因此,在anchor
块中,我们不是从match
借用,而是从临时借用,让我们可以自由修改anchor
。请参阅相关博文Stuff the Identity Function Does (in Rust)。
答案 1 :(得分:8)
您可以使用递归来满足借用检查器。这样做的缺点是为列表中的每个项目创建堆栈框架。如果你的列表很长,这肯定会遇到堆栈溢出。 LLVM会将Node::back
方法优化为循环(请参阅playground上生成的LLVM IR)
impl Node {
fn back(&mut self) -> &mut Link {
match self.next {
Some(ref mut node) => node.back(),
None => &mut self.next,
}
}
}
impl Recursive {
fn back(&mut self) -> Option<&mut Link> {
self.root.as_mut().map(|node| node.back())
}
}
答案 2 :(得分:8)
原始代码在non-lexical lifetimes启用后按原样运行:
#![feature(nll)]
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(node) = anchor {
anchor = &mut node.next;
}
anchor
}
}
fn main() {}
非词法生命周期提高了编译器借用检查器的精度,使其能够看到不再使用anchor
的可变借位。由于最近的语言更改,我们还可以简化if let
中的关键字。
答案 3 :(得分:2)
有效:
fn back(&mut self) -> &mut Link {
let mut anchor = &mut self.root;
while anchor.is_some(){
anchor = &mut {anchor}.as_mut().unwrap().next;
}
anchor
}