在 Rust 中编写一个以可迭代容器作为参数的通用函数

Question

我想编写一个通用函数，它采用任何不可改变的借用可迭代容器，例如数组、 Vec 、 BTreeSet等。由于此函数是我正在实现的特征的一部分，因此我无法更改它的签名，所以不能直接将迭代器作为参数，而且我也不能向函数签名中引入任何生命周期参数。

语境

我尝试在 Rust 中实现观察者模式。 observable 和观察者如下所示：

struct Observable<T> {
    value: T,
}

impl<T> Observable<T> {
    pub fn get(&self) -> &T {
        &self.value
    }
}

trait Observer<T> {
    fn update(&self, &Observable<T>);
}

（省略了一些与我的问题无关的功能）

现在我的目标是编写一个观察者，它可以与任意可迭代容器一起使用，这些容器包含可以赋值的项目。 它应该跟踪容器中项目的值的总和，因此保存当前的总和和一个计算任何项目值的函数。 它应该实现Observer特性，以便每次容器更改时都可以更新总和。

use std::cell::RefCell;

struct SumObserver<T> {
    current_sum: RefCell<i64>,
    get_value: Fn(&T) -> i64,
}

到目前为止的方法

我尝试编译update函数已经有一段时间了，但没有成功。 以下是我尝试过的函数版本之一：

impl<'a, T, L> Observer<L> for SumObserver<T>
where
    &'a L: IntoIterator<Item = &'a T>,
{
    fn update(&self, observable: &Observable<L>) {
        let mut sum: i64 = 0;
        for item in observable.get() {
            sum += (self.get_value)(item);
        }
        *self.current_sum.borrow_mut() = sum;
    }
}

但是，编译器抱怨参数类型T和L可能都不够长：

error[E0309]: the parameter type `T` may not live long enough
  --> src/lib.rs:22:1
   |
22 |   impl<'a, T, L> Observer<L> for SumObserver<T>
   |   ^        - help: consider adding an explicit lifetime bound `T: 'a`...
   |  _|
   | |
23 | | where
24 | |     &'a L: IntoIterator<Item = &'a T>,
25 | | {
...  |
32 | |     }
33 | | }
   | |_^
   |
note: ...so that the reference type `&'a T` does not outlive the data it points at
  --> src/lib.rs:22:1
   |
22 | / impl<'a, T, L> Observer<L> for SumObserver<T>
23 | | where
24 | |     &'a L: IntoIterator<Item = &'a T>,
25 | | {
...  |
32 | |     }
33 | | }
   | |_^

如果整个函数体被注释掉，错误消息甚至保持不变。 如果我还删除了where子句，则编译工作。

如果我按照编译器的建议向参数类型添加显式生命周期界限：

impl<'a, T: 'a, L: 'a> Observer<L> for SumObserver<T>

编译器给出以下错误：

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
  --> src/lib.rs:28:32
   |
28 |         for item in observable.get() {
   |                                ^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the method body at 26:5...
  --> src/lib.rs:26:5
   |
26 | /     fn update(&self, observable: &Observable<L>) {
27 | |         let mut sum: i64 = 0;
28 | |         for item in observable.get() {
29 | |             sum += (self.get_value)(item);
30 | |         }
31 | |         *self.current_sum.borrow_mut() = sum;
32 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:28:21
   |
28 |         for item in observable.get() {
   |                     ^^^^^^^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 22:6...
  --> src/lib.rs:22:6
   |
22 | impl<'a, T: 'a, L: 'a> Observer<L> for SumObserver<T>
   |      ^^
   = note: ...so that the types are compatible:
           expected std::iter::IntoIterator
              found std::iter::IntoIterator

我不明白这个函数中生命周期的问题。 在调用此函数的任何时候，编译器都应确保observable的借用至少持续到函数返回为止。 那时，任何对observable借用都超出了范围。

Answer 1

这是高排名特征边界 (HRTB) 的一个案例。

关键是您不希望&L在一个生命周期内实现IntoIterator<Item = &T> ，而是在L可能碰巧拥有的所有潜在生命周期内实现。

在这种情况下，您需要使用更高排名的 Trait Bound： for<'a>将负责引入生命周期名称，同时向编译器发出信号，使用它的子句应该对'a所有可能值都有效。

这意味着：

impl<T, L> Observer<L> for SumObserver<T>
where
    for<'a> &'a L: IntoIterator<Item = &'a T>,
{
    fn update(&self, observable: &Observable<L>) {
        let mut sum: i64 = 0;
        for item in observable.get() {
            sum += (self.get_value)(item);
        }
        *self.current_sum.borrow_mut() = sum;
    }
}

它编译（至少在隔离中）。

也可以看看：

• for<> 语法与常规生命周期界限有何不同？