Rust Inspect Iterator：不能将 `*` 作为不可变借用，因为它也作为可变借用

Question

为什么我不能在inspect 期间对这个向量进行push 并在skip_while 期间对它执行contains？

我已经为自己的结构 Chain 实现了自己的迭代器，如下所示：

struct Chain {
    n: u32,
}

impl Chain {
    fn new(start: u32) -> Chain {
        Chain { n: start }
    }
}

impl Iterator for Chain {
    type Item = u32;

    fn next(&mut self) -> Option<u32> {
        self.n = digit_factorial_sum(self.n);
        Some(self.n)
    }
}

现在我想做的是take，而迭代器正在生成唯一值。所以我 inspect-ing 链并推送到一个向量，然后在 take_while 范围内检查它：

let mut v = Vec::with_capacity(terms);
Chain::new(i)
    .inspect(|&x| {
        v.push(x)
    })
    .skip_while(|&x| {
        return v.contains(&x);
    })

然而，Rust 编译会吐出这个错误：

error: cannot borrow `v` as immutable because it is also borrowed as mutable [E0502]
...
borrow occurs due to use of `v` in closure
    return v.contains(&x);
           ^
previous borrow of `v` occurs here due to use in closure; the mutable borrow prevents subsequent moves, borrows, or modification of `v` until the borrow ends
    .inspect(|&x| {
        v.push(x)
    })

显然我不理解“借用”的概念。我做错了什么？

Answer 1

这里的问题是你试图同时创建对同一个变量的可变引用和不可变引用，这违反了 Rust 借用规则。而且 rustc 实际上确实很清楚地对你说。

let mut v = Vec::with_capacity(terms);
Chain::new(i)
    .inspect(|&x| {
        v.push(x)
    })
    .skip_while(|&x| {
        return v.contains(&x);
    })

在这里，您尝试在两个闭包中使用 v，第一个在 inspect() 参数中，第二个在 skip_while() 参数中。非move 闭包通过引用捕获它们的环境，因此第一个闭包的环境包含&mut v，第二个闭包的环境包含&v。闭包是在同一个表达式中创建的，所以即使保证 inspect() 在 skip_while() 之前运行并丢弃借用（我不是实际情况，因为这些是迭代器适配器，它们根本不会运行直到迭代器被消耗），由于词法借用规则，这是被禁止的。

不幸的是，这是借用检查器过于严格的例子之一。你可以做的是使用RefCell，它允许通过共享引用进行变异，但会引入一些运行时成本：

use std::cell::RefCell;

let mut v = RefCell::new(Vec::with_capacity(terms));
Chain::new(i)
    .inspect(|x| v.borrow_mut().push(*x))
    .skip_while(|x| v.borrow().contains(x))

我认为也许可以避免RefCell 的运行时损失，而改用UnsafeCell，因为当迭代器被消耗时，这些闭包只会一个接一个地运行，而不是在同时，所以不应该同时存在一个可变引用和一个不可变引用。它可能看起来像这样：

use std::cell::UnsafeCell;

let mut v = UnsafeCell::new(Vec::with_capacity(terms));
Chain::new(i)
    .inspect(|x| unsafe { (&mut *v.get()).push(*x) })
    .skip_while(|x| unsafe { (&*v.get()).contains(x) })

但我可能错了，无论如何，RefCell 的开销并没有那么高，除非这段代码运行在一个 真的 紧密循环中，所以你应该只使用 UnsafeCell 作为最后的手段，只有在没有其他方法的情况下，使用它时要格外小心。