从切片生成的迭代器使用什么类型签名？

Question

我有这个玩具示例，但这是我想要完成的：

fn lazy_vec() {
    let vec: Vec<i64> = vec![1, 2, 3, 4, 5];
    let mut iter: Box<Iterator<Item = i64>> = Box::new(vec.into_iter());
    iter = Box::new(iter.map(|x| x + 1));
    // potentially do additional similar transformations to iter
    println!("{:?}", iter.collect::<Vec<_>>());
}

这（如果我没记错的话）是一个惰性迭代器模式，实际的map 操作在调用.collect() 之前不会发生。我想对切片做同样的事情：

fn lazy_slice() {
    let vec: Vec<i64> = vec![1, 2, 3, 4, 5];
    let slice: &[i64] = &vec[..3];
    let mut iter: Box<Iterator<Item = i64>> = Box::new(slice.into_iter());
    iter = Box::new(iter.map(|x| x + 1));
    // potentially do additional similar transformations to iter
    println!("{:?}", iter.collect::<Vec<_>>());
}

这会导致类型不匹配：

error[E0271]: type mismatch resolving `<std::slice::Iter<'_, i64> as std::iter::Iterator>::Item == i64`
 --> src/main.rs:4:47
  |
4 |     let mut iter: Box<Iterator<Item = i64>> = Box::new(slice.into_iter());
  |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found i64
  |
  = note: expected type `&i64`
             found type `i64`
  = note: required for the cast to the object type `std::iter::Iterator<Item=i64>`

我不知道我需要做什么来解决这个错误。第二个note 让我觉得我需要：

iter = Box::new(iter.map(|x| x + 1) as Iterator<Item = i64>);

或

iter = Box::new(iter.map(|x| x + 1)) as Box<Iterator<Item = i64>>;

根据确切的语法（例如 expected reference, found i64 或 expected i64, found &i64），这些失败并出现其他错误。我尝试了其他方法来声明所涉及的类型，但我基本上只是在一些地方盲目地添加&和*，并没有取得任何进展。

我在这里缺少什么？为了编译，我需要改变什么？

---

编辑

这里有一个更具体的例子——我需要iter 成为mut，这样我就可以在实际调用.collect() 之前组合未知数量的此类转换。我的印象是这是一种比较常见的模式，如果不正确，请道歉。

fn lazy_vec(n: i64) {
    let vec: Vec<i64> = vec![1, 2, 3, 4, 5];
    let mut iter: Box<Iterator<Item = i64>> = Box::new(vec.into_iter());
    for _ in 0..n {
        iter = Box::new(iter.map(|x| x + 1));
    }
    println!("{:?}", iter.collect::<Vec<_>>());
}

我知道我可以以更简单的方式重写此特定任务（例如，将 n 添加到每个元素的单个 map） - 这是我遇到的问题的过度简化的 MCVE。我的问题是这适用于lazy_vec，但我不知道如何对切片做同样的事情。

---

编辑 2

我刚刚学习 Rust，其中一些术语和概念对我来说是新的。这是我在 Python 中的设想，用于比较。我的意图是对切片做同样的事情，我目前可以对向量做同样的事情。

#!/usr/bin/env python3

import itertools

ls = [i for i in range(10)]

def lazy_work(input):
  for i in range(10):
    input = (i + 1 for i in input)
  # at this point no actual work has been done
  return input

print("From list: %s" % list(lazy_work(ls)))
print("From slice: %s" % list(lazy_work(itertools.islice(ls, 5))))

显然在 Python 中打字没有问题，但希望这能更清楚地表明我的意图？

Answer 1

如What is the difference between iter and into_iter? 中所述，这些方法创建迭代器，与切片相比，在Vec 上调用时会产生不同的类型。

[T]::iter 和 [T]::into_iter 都返回一个迭代器 which yields values of type &T。这意味着返回值没有实现Iterator<Item = i64>，而是实现Iterator<Item = &i64>，如错误消息所述。

但是，您随后的map 语句更改迭代器项的类型为i64，这意味着迭代器的类型也需要更改。打个比方，你基本上是这样尝试的：

let mut a: &i64 = &42;
a = 99;

Iterator::cloned 的存在是为了克隆迭代值。在这种情况下，它将&i64 转换为i64，本质上是取消引用该值：

fn lazy_slice(n: i64) {
    let array = [1i64, 2, 3, 4, 5];
    let mut iter: Box<Iterator<Item = i64>> = Box::new(array.iter().cloned());
    for _ in 0..n {
        iter = Box::new(iter.map(|x| x + 1));
    }
    println!("{:?}", iter.collect::<Vec<_>>());
}