在 F# 中对平面序列进行延迟分组

Question

给定一系列项目如下：

[ ("a", 1); ("a", 2); ("a", 3); ("b", 1); ("c", 2); ("c", 3) ]

我怎样才能把这个懒惰地转换成：

{ ("a", { 1; 2; 3}); ("b", { 1 }); ("c", { 2; 3}) }

您可以假设输入数据源已经按分组键元素排序，例如"a" "b" 和 "c"。

我在那里使用 { } 表示它是一个惰性求值的项目序列。

我已经让它在源序列的 IEnumerator 上运行的两个 while 循环命令式地工作，但这涉及创建参考变量和突变等。我确信有更好的方法来做到这一点，也许与递归或使用 Seq 库中的一些操作，例如扫描还是展开？

Answer 1

如果你想在IEnumerable<'T> 上实现它（让它变得懒惰），那么它必然会有点势在必行，因为用于迭代输入的IEnumerator<'T> 类型是势在必行的。但其余的可以写成使用序列表达式的递归函数。

以下在第一级是惰性的（它惰性地产生每个组），但它不会惰性地产生组的元素（我认为这会有非常微妙的语义）：

/// Group adjacent elements of 'input' according to the 
/// keys produced by the key selector function 'f'
let groupAdjacent f (input:seq<_>) = seq {
  use en = input.GetEnumerator()

  // Iterate over elements and keep the key of the current group
  // together with all the elements belonging to the group so far
  let rec loop key acc = seq { 
    if en.MoveNext() then 
      let nkey = f en.Current 
      if nkey = key then 
        // If the key matches, append to the group so far
        yield! loop key (en.Current::acc)
      else 
        // Otherwise, produce the group collected so far & start a new one
        yield List.rev acc
        yield! loop nkey [en.Current]
    else
      // At the end of the sequence, produce the last group
      yield List.rev acc
  }
  // Start with the first key & first value as the accumulator
  if en.MoveNext() then 
    yield! loop (f en.Current) [en.Current] }

不幸的是，这个（非常有用！）函数不包含在标准 F# 库中，所以如果你想对 相邻 元素（而不是使用 Seq.groupBy 列表中的任意元素）进行分组，你必须自己定义它......

Answer 2

let p = [("a", 1); ("a", 2); ("a", 3); ("b", 1); ("c", 2); ("c", 3)]
let l = p |> Seq.groupBy fst |> Seq.map(fun x -> fst x, snd x |> Seq.map snd) 

Answer 3

在F#+ 中有一个通用函数chunkBy 可用于执行此操作：

#r "FSharpPlus.dll"
open FSharpPlus

seq [ ("a", 1); ("a", 2); ("a", 3); ("b", 1); ("c", 2); ("c", 3) ]
    |> chunkBy fst 
    |> map (fun (x,y) -> x, map snd y)

它适用于seq、array 和list。

seq 的实现与 Tomas 的 groupdAdjacent 几乎相同。

Answer 4

Seq.groupBy fst

会成功的