如何创建一个从迭代器的迭代器创建笛卡尔积迭代器的函数？

Question

如果我想在 Haskell 中创建列表列表的笛卡尔积，我可以这样做：

product [] = [[]]
product (xs:xss) = concatMap (\k -> map (k:) (product1 xss)) xs

甚至这个：

sequence xss

我正在尝试实现一个高效的迭代器，它可以在 Rust 中做同样的事情，但我不确定我的尝试有什么问题：

use std::iter::{empty, once};

fn product<T, I, V>(xss: I) -> Box<Iterator<Item = Iterator<Item = T>>>
where
    T: Clone,
    V: IntoIterator<Item = T>,
    I: IntoIterator<Item = V>,
{
    Box::new(xss.into_iter().fold(once(empty()), |acc, xs| {
        xs.into_iter().flat_map(|x| acc.map(|ys| ys.chain(once(x))))
    }))
}

fn main() {
    let data = vec![[1, 2, 3], [10, 20, 30], [100, 200, 300]];
    let it: Vec<Vec<u32>> = product(data).collect();
    println!("{:?}", it);
}

(playground)

产生这些错误：

error[E0308]: mismatched types
  --> src/main.rs:10:9
   |
10 |         xs.into_iter().flat_map(|x| acc.map(|ys| ys.chain(once(x))))
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `std::iter::Once`, found struct `std::iter::FlatMap`
   |
   = note: expected type `std::iter::Once<std::iter::Empty<T>>`
              found type `std::iter::FlatMap<<V as std::iter::IntoIterator>::IntoIter, std::iter::Map<std::iter::Once<std::iter::Empty<T>>, [closure@src/main.rs:10:45: 10:67 x:_]>, [closure@src/main.rs:10:33: 10:68 acc:_]>`

error[E0271]: type mismatch resolving `<std::iter::Once<std::iter::Empty<T>> as std::iter::Iterator>::Item == std::iter::Iterator<Item=T>`
  --> src/main.rs:9:5
   |
9  | /     Box::new(xss.into_iter().fold(once(empty()), |acc, xs| {
10 | |         xs.into_iter().flat_map(|x| acc.map(|ys| ys.chain(once(x))))
11 | |     }))
   | |_______^ expected struct `std::iter::Empty`, found trait std::iter::Iterator
   |
   = note: expected type `std::iter::Empty<T>`
              found type `std::iter::Iterator<Item=T>`
   = note: required for the cast to the object type `std::iter::Iterator<Item=std::iter::Iterator<Item=T>>`

error[E0277]: the trait bound `[{integer}; 3]: std::iter::Iterator` is not satisfied
  --> src/main.rs:16:29
   |
16 |     let it: Vec<Vec<u32>> = product(data).collect();
   |                             ^^^^^^^ `[{integer}; 3]` is not an iterator; maybe try calling `.iter()` or a similar method
   |
   = help: the trait `std::iter::Iterator` is not implemented for `[{integer}; 3]`
   = note: required because of the requirements on the impl of `std::iter::IntoIterator` for `[{integer}; 3]`
   = note: required by `product`

error: the `collect` method cannot be invoked on a trait object
  --> src/main.rs:16:43
   |
16 |     let it: Vec<Vec<u32>> = product(data).collect();
   |                                           ^^^^^^^

第一个错误让我感觉 Rust 甚至无法使用 fold 创建一个惰性消耗的迭代器，因为 Empty<T> 是一个 Iterator<Item = T>（至少在概念上），但我希望我错了。

Answer 1

对于它的价值，Itertools crate 实现了一个可行的笛卡尔积函数：

use itertools::Itertools;

let it = (0..2).cartesian_product("αβ".chars());
itertools::assert_equal(it, vec![(0, 'α'), (0, 'β'), (1, 'α'), (1, 'β')]);

Answer 2

您的方法注定要失败的第一个原因是因为您试图将设计用于处理列表的算法转换为处理迭代器的算法。列表适用于函数式方法，而迭代器则不适用，因为它们有状态。 next(&mut self) 函数每次使用相同的参数调用时都不会返回相同的值，而 next(x:xs) 函数会。这就是implementation found in itertools 克隆迭代器的原因：保存它们的初始状态并在集合的下一次迭代中恢复它。

第二个原因，即错误消息背后的原因，是您正在与 Rust 的类型系统作斗争。您对迭代器函数（fold、flat_map 等）的所有调用的结果值不是特征对象，而是“具体类型”。例如iterator.fold(init, fn) 的结果类型是init 的类型。这就是为什么当你传递 fold 一个不返回 std::iter::Empty<T> 的 lambda 时编译器会抱怨。

但情况会变得更糟。您可以想象将std::iter::Empty<T> 强制或强制转换为特征对象。唉，对象安全是必需的。简而言之，"A good intuition is “except in special circumstances, if your trait’s method uses Self, it is not object-safe."。但是迭代器的主要方法是next(&mut self)。