实现成对迭代器

Question

我无法为一个函数编写代码，该函数接受一个迭代器并返回一个迭代器，该迭代器像这样成对迭代(Option<T>, T)

a = [1,2,3]
assert pairwise(a) == `[(None, 1), (Some(1), 2), (Some(2), 3)]

fn pairwise<I, T>(&xs: &I) -> I
where
    I: Iterator<Item = T>,
{
    [None].iter().chain(xs.iter().map(Some)).zip(xs.iter())
}

fn main() {
    let data: Vec<i32> = vec![1, 2, 3];
    let newdata: Vec<Option<i32>, i32> = pairwise(&data).collect();
    println!("{:?}", newdata);
}

error[E0599]: no method named `iter` found for type `I` in the current scope
 --> src/main.rs:3:28
  |
3 |     [None].iter().chain(xs.iter().map(Some)).zip(xs.iter())
  |                            ^^^^
  |

不知道为什么xs不可迭代。 我已经在where子句中说明了where不是吗？

Answer 1

fn pairwise<I, T>(&xs: &I) -> I

这没有意义。 请参阅返回迭代器（或任何其他特征）的正确方法是什么？ 当用作 for 循环变量时，`e1` 和 `&e2` 之间有什么区别？ .

 I: Iterator<Item = T>,

没有理由指定Item是T 。

 [None].iter()

最好使用iter::once 。

 xs.iter()

标准库中没有定义iter方法的特征。 也许你的意思是IntoIterator ？

 let data: Vec<i32> = vec![1, 2, 3]

没有理由在这里指定类型； i32是默认的整数类型。

 Vec<Option<i32>, i32> Vec<Option<i32>, i32>> // original version

这不是Vec的有效类型，您的原始表单甚至没有平衡符号。

---

毕竟，您面临着艰难的选择。 您的示例代码传入了一个迭代器，该迭代器具有对切片的引用，但您已经编写了断言，以便您希望获得非引用。 您还尝试两次使用任意迭代器； 不能保证这样的事情是可行的。

我看到的最通用的形式是：

use std::iter;

fn pairwise<I>(right: I) -> impl Iterator<Item = (Option<I::Item>, I::Item)>
where
    I: IntoIterator + Clone,
{
    let left = iter::once(None).chain(right.clone().into_iter().map(Some));
    left.zip(right)
}

fn main() {
    let data = vec![1, 2, 3];

    let newdata: Vec<_> = pairwise(&data).collect();
    assert_eq!(newdata, [(None, &1), (Some(&1), &2), (Some(&2), &3)]);

    let newdata: Vec<_> = pairwise(data.iter().copied()).collect();
    assert_eq!(newdata, [(None, 1), (Some(1), 2), (Some(2), 3)]);
}

另见：

• 在 Rust 中迭代切片的值而不是引用？
• 如何迭代和过滤数组？
• 如何从 Vector 创建非消耗迭代器
• 为什么我可以遍历一个切片两次，而不是一个向量？
• 编译器建议我添加一个“静态生命周期”，因为参数类型的生命周期可能不够长，但我认为这不是我想要的
• 返回迭代器（或任何其他特征）的正确方法是什么？

Answer 2

我知道 OP 要求“外部成对”（ [(None, 1), (Some(1), 2), (Some(2), 3)] ），但这是我如何将其调整为“内部成对”（ [(1, 2), (2, 3)] ):

 fn inner_pairwise<I>(right: I) -> impl Iterator<Item = (I::Item, I::Item)> where I: IntoIterator + Clone, { let left = right.clone().into_iter().skip(1); left.zip(right) }

对于这里的“内部成对”的任何人，您正在寻找Itertools::tuple_windows 。