Linq 是否有F#'的懒惰版本；s Seq.groupBy函数？

我想使用如下代码惰性地对一个非常大的序列进行分组：

// native F# version
let groups =
    Seq.initInfinite id
        |> Seq.groupBy (fun i -> i % 10)
for (i, group) in groups |> Seq.take 5 do
    printfn "%A: %A" i (group |> Seq.take 5)

预期产出为：

1: seq [1; 11; 21; 31; ...]
2: seq [2; 12; 22; 32; ...]
3: seq [3; 13; 23; 33; ...]
4: seq [4; 14; 24; 34; ...]
5: seq [5; 15; 25; 35; ...]

然而，在实践中，该程序无限循环，不打印任何内容。有可能在F#中实现这一点吗

我愿意使用Linq而不是本机函数，但是GroupBy和ToLookup都会产生相同的行为（尽管Linq的GroupBy被认为是懒惰的）：

---

也许我无意中做了一些事情，导致了急切的评估？

有两件事要说：

首先，你怎么知道，在一个无限序列中会有多少组？换句话说，你需要具体化多少项才能从上面得到你的5组？如果你要求11组，你需要实现多少？从概念上讲，非正式地解释当你懒洋洋地分组时会发生什么是不容易的

---

第二，group by的Rx版本是懒惰的，可能是你能得到的最接近你想要的：这个版本的group by工作，因为它对每个元素做出反应并触发相应的组，因此，当一个新元素被消费时，你会得到一个事件，你会得到它发生在哪个组中的信息，与获取组列表相反。

有两件事要说：

首先，你怎么知道，在一个无限序列中会有多少组？换句话说，你需要具体化多少项才能从上面得到你的5组？如果你要求11组，你需要实现多少？从概念上讲，非正式地解释当你懒洋洋地分组时会发生什么是不容易的

---

第二，group by的Rx版本是懒惰的，可能是你能得到的最接近你想要的：这个版本的group by工作，因为它对每个元素做出反应并触发相应的组，因此，当一个新元素被消费时，你会得到一个事件，你会得到它发生在哪个组中的信息，与获取组列表相反。

有两件事要说：

首先，你怎么知道，在一个无限序列中会有多少组？换句话说，你需要具体化多少项才能从上面得到你的5组？如果你要求11组，你需要实现多少？从概念上讲，非正式地解释当你懒洋洋地分组时会发生什么是不容易的

---

第二，group by的Rx版本是懒惰的，可能是你能得到的最接近你想要的：这个版本的group by工作，因为它对每个元素做出反应并触发相应的组，因此，当一个新元素被消费时，你会得到一个事件，你会得到它发生在哪个组中的信息，与获取组列表相反。

有两件事要说：

首先，你怎么知道，在一个无限序列中会有多少组？换句话说，你需要具体化多少项才能从上面得到你的5组？如果你要求11组，你需要实现多少？从概念上讲，非正式地解释当你懒洋洋地分组时会发生什么是不容易的

---

第二，group by的Rx版本是懒惰的，可能是你能得到的最接近你想要的：这个版本的group by工作，因为它对每个元素做出反应并触发相应的组，因此，当一个新元素被消费时，你会得到一个事件，你会得到它发生在哪个组中的信息，与获取组列表相反。

My library for F#有一个所谓（）的实现，它既懒惰又并发/异步，还提供一个操作。

My library for F#有一个所谓（）的实现，它既懒惰又并发/异步，还提供一个操作。

我的F#库有一个所谓（）的实现，它既懒惰又并发/异步，还提供一个操作。

我的F#库有一个所谓（）的实现，它们既懒惰又并发/异步，还提供了一个操作。

不，不是你，而是方法实现。他们并不是真正的懒惰者——除非你需要结果，否则他们不会开始评估，但是所有的结果都会在一次生成。但那是因为像你这样的场景是非常罕见的。好吧，那太令人失望了。谢谢。不，不是你，是方法实现。他们并不是真正的懒惰者——除非你需要结果，否则他们不会开始评估，但是所有的结果都会在一次生成。但那是因为像你这样的场景是非常罕见的。好吧，那太令人失望了。谢谢。不，不是你，是方法实现。他们并不是真正的懒惰者——除非你需要结果，否则他们不会开始评估，但是所有的结果都会在一次生成。但那是因为像你这样的场景是非常罕见的。好吧，那太令人失望了。谢谢。不，不是你，是方法实现。他们并不是真正的懒惰者——除非你需要结果，否则他们不会开始评估，但是所有的结果都会在一次生成。但那是因为像你这样的场景是非常罕见的。好吧，那太令人失望了。谢谢。既然组本身是以惰性顺序返回的，为什么我需要知道有多少组是“预先”的呢？如果第5组直到序列中的第万亿个元素才生成，那么显然“take 5”组将非常昂贵。尽管如此，组级别的“taken”应该返回序列生成的前n个组，就像元素级别的“taken”返回序列生成的前n个元素一样。组级序列与元素级序列在哪些方面如此不同？（另外，实际上，我确实知道在这种情况下会有多少组，因为分组函数是mod运算符

// Linq version
let groups =
    Enumerable.GroupBy(
        Seq.initInfinite id,
        (fun i -> i % 10))
for group in groups |> Seq.take 5 do
    printfn "%A" (group |> Seq.take 5)