我想编写一个泛型函数，它接受任何不可变的借用的可迭代容器，如数组，Vec，BTreeSet等。由于此函数是我正在实现的特征的一部分，我无法更改它的签名，所以不可能直接将迭代器作为参数，我也不能将任何生命周期参数引入函数签名。
我试图在Rust中实现观察者模式。观察者和观察者看起来如下：
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都超出了范围。
这是较高等级特征界（HRTB）的一个案例。
关键是你不希望&L在一生中实现IntoIterator<Item = &T>，但是对于L可能碰巧拥有的所有潜在生命周期。
在这种情况下，您需要使用更高级别的特征绑定：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;
}
}
编译（至少是孤立的）。
也可以看看：