Rust中如何将迭代器数组转换为返回数组的迭代器？

要实现一个能将固定长度迭代器数组打包的迭代器，每次从每个子迭代器取一个元素组成数组返回，直到最短的子迭代器耗尽，我们可以利用Rust的const泛型特性来完成，无需依赖第三方库。

核心实现 #

首先定义一个持有迭代器数组的结构体，再为它实现Iterator trait：

struct ZipArray<I, const N: usize>
where
    I: Iterator,
{
    iterators: [I; N],
}

impl<I, const N: usize> Iterator for ZipArray<I, N>
where
    I: Iterator,
{
    type Item = [I::Item; N];

    fn next(&mut self) -> Option<Self::Item> {
        let mut items = Vec::with_capacity(N);
        // 遍历所有迭代器，尝试取元素，任一迭代器耗尽则返回None
        for iter in &mut self.iterators {
            match iter.next() {
                Some(item) => items.push(item),
                None => return None,
            }
        }
        // 确认所有元素都存在，安全转换为固定长度数组
        items.try_into().ok()
    }
}

// 对外暴露的zip_array函数，接收迭代器数组并返回打包后的迭代器
fn zip_array<I, const N: usize>(iterators: [I; N]) -> ZipArray<I, N>
where
    I: Iterator,
{
    ZipArray { iterators }
}

测试验证 #

用你提供的示例代码测试：

fn main() {
    let arr = [0..9, 2..8, 4..8, 3..5];
    for [a, b, c, d] in zip_array(arr) {
        println!("{a} {b} {c} {d}");
    }
    println!("end of iteration");
}

运行结果完全符合预期：

0 2 4 3
1 3 5 4
end of iteration

补充方案 #

如果不想手动实现，也可以借助itertools的izip!宏，但需要手动将数组元素展开为元组（因为izip!原生支持元组而非数组）：

use itertools::izip;

fn main() {
    let arr = [0..9, 2..8, 4..8, 3..5];
    for (a, b, c, d) in izip!(arr[0], arr[1], arr[2], arr[3]) {
        println!("{a} {b} {c} {d}");
    }
    println!("end of iteration");
}

这种方式适合数组长度较短的场景，长度较大时不如自定义的zip_array灵活。

内容的提问来源于stack exchange，提问作者Lina Blume