Rust：没有引用时如何使用生命周期？ [复制]

Question

我有这个代码：

use std::hash::Hash;
use std::rc::Rc;

struct Counter<V> {
    value: V,
}

struct LFUCache<K, V> {
    values: Vec<(Rc<K>, Counter<V>)>,
}

impl<K: Hash + Eq, V> IntoIterator for LFUCache<K, V> {
    type Item = (Rc<K>, V);
    type IntoIter = Box<dyn Iterator<Item=(Rc<K>, V)>>;

    fn into_iter(self) -> Self::IntoIter {
        return Box::new(self
            .values
            .into_iter()
            .map(|(key, value_counter)| (key, value_counter.value)));
    }
}

我收到一个错误：

error[E0310]: the parameter type `K` may not live long enough
   --> src/lib.rs:167:16
    |
162 |   impl<K: Hash + Eq, V> IntoIterator for LFUCache<K, V> {
    |        -- help: consider adding an explicit lifetime bound `K: 'static`...
...
167 |           return Box::new(self
    |  ________________^
168 | |             .values
169 | |             .into_iter()
170 | |             .map(|(key, value_counter)| (key, value_counter.value)));
    | |____________________________________________________________________^
    |
note: ...so that the type `std::iter::Map<std::collections::hash_map::IntoIter<std::rc::Rc<K>, ValueCounter<V>>, [closure@src/lib.rs:170:18: 170:67]>` will meet its required lifetime bounds
   --> src/lib.rs:167:16
    |
167 |           return Box::new(self
    |  ________________^
168 | |             .values
169 | |             .into_iter()
170 | |             .map(|(key, value_counter)| (key, value_counter.value)));

我想表达盒装迭代器应该与 LFU 缓存一样长的意图。但是，由于没有引用，我无法获得任何生命周期。

我该如何解决这个问题？

Answer 1

这并没有完全回答这个问题，但可能值得注意的是，使用盒装 trait 对象来保存返回的迭代器会导致生命周期的困难。如果直接返回迭代器，那就没问题了：

use std::hash::Hash;
use std::rc::Rc;
use std::{iter, vec};

struct Counter<V> {
    value: V,
}

struct LFUCache<K, V> {
    values: Vec<(Rc<K>, Counter<V>)>,
}

impl<K: Hash + Eq, V> IntoIterator for LFUCache<K, V> {
    type Item = (Rc<K>, V);
    type IntoIter =
        iter::Map<vec::IntoIter<(Rc<K>, Counter<V>)>, fn((Rc<K>, Counter<V>)) -> (Rc<K>, V)>;

    fn into_iter(self) -> Self::IntoIter {
        self.values
            .into_iter()
            .map(|(key, value_counter)| (key, value_counter.value))
    }
}

通过避免 Box 分配和 vtable 查找，这也可能具有更好的性能。这里的缺点是迭代器有一个相当复杂的类型，你必须编写它。最终，Rust 的“impl Trait”功能可能会被扩展以覆盖这种情况，这样您就不必显式地编写类型。事实上，使用 nightly Rust 你已经可以使用不稳定的特性来做到这一点：

#![feature(type_alias_impl_trait)]    

impl<K: Hash + Eq, V> IntoIterator for LFUCache<K, V> {
    type Item = (Rc<K>, V);
    type IntoIter = impl Iterator<Item = (Rc<K>, V)>;

    fn into_iter(self) -> Self::IntoIter {
        self.values
            .into_iter()
            .map(|(key, value_counter)| (key, value_counter.value))
    }
}

Answer 2

我想表达的意图是盒装迭代器应该与 LFU 缓存一样长。

方法into_iter 消耗 self，所以这没有意义。只要调用into_iter()，LFU 缓存就会消失。

如果你想保留它，那么你可以为&LFUCache 实现IntoIterator。现在你有了一个引用——也就是一个生命周期——迭代器可以绑定到它。请注意，迭代将移动V 类型的值，因此您需要将其限制为Copy（或至少Clone），或者使迭代器项包含对V 的引用。这是使用引用的工作示例：

impl<'a, K: Hash + Eq, V> IntoIterator for &'a LFUCache<K, V> {
    type Item = (Rc<K>, &'a V);
    type IntoIter = Box<dyn Iterator<Item=(Rc<K>, &'a V)> + 'a>;

    fn into_iter(self) -> Self::IntoIter {
        return Box::new(self
            .values
            .iter()
            .map(|(key, value_counter)| (key.clone(), &value_counter.value)));
    }
}