F# 多序列的惰性笛卡尔积（序列序列）

你能推荐一种更简单更清晰的方法来编写这个函数吗

let cartesian_product sequences = 
    let step acc sequence = seq { 
        for x in acc do 
        for y in sequence do 
        yield Seq.append x [y] }
    Seq.fold step (Seq.singleton Seq.empty) sequences 

---

我对朱丽叶的功能进行了基准测试：

let items = List.init 6 (fun _ -> [0..9])
cart1 items |> Seq.length |> ignore

Real:00:03.324，CPU:00:00:03.322，GC gen0:80，gen1:0，gen2:0

还有一个稍加修改的（使之成为苹果对苹果的比较）版本：

let cartesian items =
  items |> Seq.fold (fun acc s ->
    seq { for x in acc do for y in s do yield x @ [y] }) (Seq.singleton [])

cartesian items |> Seq.length |> ignore

Real:00:00.763，CPU:00:00.780，GC gen0:37，gen1:2，gen2:1

你的速度明显更快（并且导致地面军事系统更少）。在我看来，您拥有的很好。

不那么优雅，但（似乎）更快的解决方案：

let cartesian_product2 sequences = 
    let step acc sequence = seq { 
        for x in acc do 
        for y in sequence do 
        yield seq { yield! x ; yield y } }
    Seq.fold step (Seq.singleton Seq.empty) sequences 

)

---

请参阅和，对于基本上与此F#解决方案相同的C#解决方案，请参阅这似乎更快，因为您返回的是

seq

，而不是

seq

，即您的内部序列没有被评估。试试看

cartesian_product2 items |>Seq.map Seq.toList |>Seq.length

@Daniel：好的观点。但是它仍然比作者的解决方案快2倍（同时仍然是懒惰的，根据需要）。这个解决方案在构建序列和实现序列方面是否更快？或者两者都没有，因为测试没有实现子序列？老问题，但是你有一个gen 2集合。这意味着地面军事系统的数量减少了多少？

> cartesian items |> Seq.length;;
Real: 00:00:00.405, CPU: 00:00:00.405, GC gen0: 37, gen1: 1, gen2: 0
val it : int = 1000000
> cartesian_product2 items |> Seq.length;;
Real: 00:00:00.228, CPU: 00:00:00.234, GC gen0: 18, gen1: 0, gen2: 0
val it : int = 1000000