我无法表达Iterator实现的返回值的生命周期。如何在不更改迭代器的返回值的情况下编译此代码？我希望它能返回一个引用向量。
很明显，我没有正确使用生命周期参数，但在尝试了我放弃的各种方法之后，我不知道如何处理它。
use std::iter::Iterator;
struct PermutationIterator<T> {
vs: Vec<Vec<T>>,
is: Vec<usize>,
}
impl<T> PermutationIterator<T> {
fn new() -> PermutationIterator<T> {
PermutationIterator {
vs: vec![],
is: vec![],
}
}
fn add(&mut self, v: Vec<T>) {
self.vs.push(v);
self.is.push(0);
}
}
impl<T> Iterator for PermutationIterator<T> {
type Item = Vec<&'a T>;
fn next(&mut self) -> Option<Vec<&T>> {
'outer: loop {
for i in 0..self.vs.len() {
if self.is[i] >= self.vs[i].len() {
if i == 0 {
return None; // we are done
}
self.is[i] = 0;
self.is[i - 1] += 1;
continue 'outer;
}
}
let mut result = vec![];
for i in 0..self.vs.len() {
let index = self.is[i];
result.push(self.vs[i].get(index).unwrap());
}
*self.is.last_mut().unwrap() += 1;
return Some(result);
}
}
}
fn main() {
let v1: Vec<_> = (1..3).collect();
let v2: Vec<_> = (3..5).collect();
let v3: Vec<_> = (1..6).collect();
let mut i = PermutationIterator::new();
i.add(v1);
i.add(v2);
i.add(v3);
loop {
match i.next() {
Some(v) => {
println!("{:?}", v);
}
None => {
break;
}
}
}
}
error[E0261]: use of undeclared lifetime name `'a`
--> src/main.rs:23:22
|
23 | type Item = Vec<&'a T>;
| ^^ undeclared lifetime
答案 0 :(得分：23)
据我所知，你想要迭代器将引用向量返回给自己，对吧？不幸的是，这在Rust中是不可能的。
这是精简的Iterator特征：
trait Iterator {
type Item;
fn next(&mut self) -> Option<Item>;
}
请注意，&mut self和Option<Item>之间没有终身连接。这意味着next()方法无法将引用返回到迭代器本身。您无法表达返回引用的生命周期。这基本上是你无法找到指定正确生命周期的方法的原因 - 它看起来像这样：
fn next<'a>(&'a mut self) -> Option<Vec<&'a T>>
，但这不是next()特征的有效Iterator方法。
这样的迭代器（可以将引用返回给自己的迭代器）称为流迭代器。如果需要，您可以找到更多here，here和here。
更新。但是，您可以从迭代器返回对其他结构的引用 - 这是大多数集合迭代器的工作方式。它看起来像这样：
pub struct PermutationIterator<'a, T> {
vs: &'a [Vec<T>],
is: Vec<usize>
}
impl<'a, T> Iterator for PermutationIterator<'a, T> {
type Item = Vec<&'a T>;
fn next(&mut self) -> Option<Vec<&'a T>> {
...
}
}
注意'a块上现在声明了生命周期impl。可以这样做（事实上是必需的）因为你需要在结构上指定生命周期参数。然后，您可以在'a和Item返回类型中使用相同的next()。同样，这是大多数集合迭代器的工作原理。
答案 1 :(得分：6)
@VladimirMatveev's answer如何解释为什么您的代码无法编译是正确的。简而言之，它表示迭代器不能从内部产生借来的值。
但是，它可以从其他东西中获得借来的价值。这是Vec和Iter所取得的成果：Vec拥有值，而Iter只是一个能够在{{1}内产生引用的包装器}。
这是一种可以实现您想要的设计。与Vec和Vec一样，迭代器只是实际拥有值的其他容器的包装器。
Iter与您的初始问题无关。如果这只是我，我会确保所有借来的载体都是一次性的。我们的想法是删除对use std::iter::Iterator;
struct PermutationIterator<'a, T: 'a> {
vs : Vec<&'a [T]>,
is : Vec<usize>
}
impl<'a, T> PermutationIterator<'a, T> {
fn new() -> PermutationIterator<'a, T> { ... }
fn add(&mut self, v : &'a [T]) { ... }
}
impl<'a, T> Iterator for PermutationIterator<'a, T> {
type Item = Vec<&'a T>;
fn next(&mut self) -> Option<Vec<&'a T>> { ... }
}
fn main() {
let v1 : Vec<i32> = (1..3).collect();
let v2 : Vec<i32> = (3..5).collect();
let v3 : Vec<i32> = (1..6).collect();
let mut i = PermutationIterator::new();
i.add(&v1);
i.add(&v2);
i.add(&v3);
loop {
match i.next() {
Some(v) => { println!("{:?}", v); }
None => {break;}
}
}
}
的重复调用，并在构造时直接传递所有借用的向量：
add（编辑：将迭代器设计更改为use std::iter::{Iterator, repeat};
struct PermutationIterator<'a, T: 'a> {
...
}
impl<'a, T> PermutationIterator<'a, T> {
fn new(vs: Vec<&'a [T]>) -> PermutationIterator<'a, T> {
let n = vs.len();
PermutationIterator {
vs: vs,
is: repeat(0).take(n).collect(),
}
}
}
impl<'a, T> Iterator for PermutationIterator<'a, T> {
...
}
fn main() {
let v1 : Vec<i32> = (1..3).collect();
let v2 : Vec<i32> = (3..5).collect();
let v3 : Vec<i32> = (1..6).collect();
let vall: Vec<&[i32]> = vec![&v1, &v2, &v3];
let mut i = PermutationIterator::new(vall);
}
而不是Vec<&'a [T]>。使用引用容器比构建容器更容易参考容器。）
答案 2 :(得分：1)
正如其他答案中所提到的，这被称为流迭代器，它需要Rust Iterator的不同保证。提供此类功能的一个箱子恰当地称为streaming-iterator，它提供StreamingIterator特征。
以下是实施特征的一个例子：
extern crate streaming_iterator;
use streaming_iterator::StreamingIterator;
struct Demonstration {
scores: Vec<i32>,
position: usize,
}
// Since `StreamingIterator` requires that we be able to call
// `advance` before `get`, we have to start "before" the first
// element. We assume that there will never be the maximum number of
// entries in the `Vec`, so we use `usize::MAX` as our sentinel value.
impl Demonstration {
fn new() -> Self {
Demonstration {
scores: vec![1, 2, 3],
position: std::usize::MAX,
}
}
fn reset(&mut self) {
self.position = std::usize::MAX;
}
}
impl StreamingIterator for Demonstration {
type Item = i32;
fn advance(&mut self) {
self.position = self.position.wrapping_add(1);
}
fn get(&self) -> Option<&Self::Item> {
self.scores.get(self.position)
}
}
fn main() {
let mut example = Demonstration::new();
loop {
example.advance();
match example.get() {
Some(v) => {
println!("v: {}", v);
}
None => break,
}
}
example.reset();
loop {
example.advance();
match example.get() {
Some(v) => {
println!("v: {}", v);
}
None => break,
}
}
}
不幸的是，在实现RFC 1598的generic associated types (GATs)之前，流式迭代器将受到限制。
答案 3 :(得分：0)
我不久前写了这段代码，不知何故在这里偶然发现了这个问题。它完全符合问题的要求：它展示了如何实现一个迭代器，将其回调传递给自身的引用。
它为 .iter_map() 实例添加了一个 IntoIterator 方法。最初我认为它应该为 Iterator 本身实现，但这是一个不太灵活的设计决策。
我为它创建了一个小板条箱并将我的代码发布到 GitHub 上，以防您想尝试使用它，您can find it here。
WRT OP 在为项目定义生命周期时遇到了麻烦，我在依赖默认省略的生命周期时没有遇到任何此类问题。
这是一个用法示例。请注意，回调接收的参数是迭代器本身，回调预计会从中提取数据并按原样传递或执行任何其他操作。
use iter_map::IntoIterMap;
let mut b = true;
let s = "hello world!".chars().peekable().iter_map(|iter| {
if let Some(&ch) = iter.peek() {
if ch == 'o' && b {
b = false;
Some('0')
} else {
b = true;
iter.next()
}
} else { None }
}).collect::<String>();
assert_eq!(&s, "hell0o w0orld!");
因为 IntoIterMap 通用特征是为 IntoIterator 实现的，所以您可以从支持该接口的任何东西中获得“迭代映射”。例如，可以直接从数组中创建一个，如下所示：
use iter_map::*;
fn main()
{
let mut i = 0;
let v = [1, 2, 3, 4, 5, 6].iter_map(move |iter| {
i += 1;
if i % 3 == 0 {
Some(0)
} else {
iter.next().copied()
}
}).collect::<Vec<_>>();
assert_eq!(v, vec![1, 2, 0, 3, 4, 0, 5, 6, 0]);
}
这是完整的代码 - 用这么少的代码来实现真是太神奇了，而且在将它们组合在一起时，一切似乎都运行得很顺利。它让我对 Rust 本身的灵活性及其设计决策有了新的认识。
/// Adds `.iter_map()` method to all IntoIterator classes.
///
impl<F, I, J, R, T> IntoIterMap<F, I, R, T> for J
//
where F: FnMut(&mut I) -> Option<R>,
I: Iterator<Item = T>,
J: IntoIterator<Item = T, IntoIter = I>,
{
/// Returns an iterator that invokes the callback in `.next()`, passing it
/// the original iterator as an argument. The callback can return any
/// arbitrary type within an `Option`.
///
fn iter_map(self, callback: F) -> ParamFromFnIter<F, I>
{
ParamFromFnIter::new(self.into_iter(), callback)
}
}
/// A trait to add the `.iter_map()` method to any existing class.
///
pub trait IntoIterMap<F, I, R, T>
//
where F: FnMut(&mut I) -> Option<R>,
I: Iterator<Item = T>,
{
/// Returns a `ParamFromFnIter` iterator which wraps the iterator it's
/// invoked on.
///
/// # Arguments
/// * `callback` - The callback that gets invoked by `.next()`.
/// This callback is passed the original iterator as its
/// parameter.
///
fn iter_map(self, callback: F) -> ParamFromFnIter<F, I>;
}
/// Implements an iterator that can be created from a callback.
/// does pretty much the same thing as `std::iter::from_fn()` except the
/// callback signature of this class takes a data argument.
pub struct ParamFromFnIter<F, D>
{
callback: F,
data: D,
}
impl<F, D, R> ParamFromFnIter<F, D>
//
where F: FnMut(&mut D) -> Option<R>,
{
/// Creates a new `ParamFromFnIter` iterator instance.
///
/// This provides a flexible and simple way to create new iterators by
/// defining a callback.
/// # Arguments
/// * `data` - Data that will be passed to the callback on each
/// invocation.
/// * `callback` - The callback that gets invoked when `.next()` is invoked
/// on the returned iterator.
///
pub fn new(data: D, callback: F) -> Self
{
ParamFromFnIter { callback, data }
}
}
/// Implements Iterator for ParamFromFnIter.
///
impl<F, D, R> Iterator for ParamFromFnIter<F, D>
//
where F: FnMut(&mut D) -> Option<R>,
{
type Item = R;
/// Iterator method that returns the next item.
/// Invokes the client code provided iterator, passing it `&mut self.data`.
///
fn next(&mut self) -> Option<Self::Item>
{
(self.callback)(&mut self.data)
}
}