SCALA-解释此函数的流程

有人能给我解释一下这个函数的流程吗？我想，有了这个代码，结果会是：

List（（a，1）（a，2）（b，1）（b，2））

。我不明白结果

列表（（a，1）、（b，1））

是如何实现的

/** Returns the list of all subsets of the occurrence list.
    * This includes the occurrence itself, i.e. `List(('k', 1), ('o', 1))`
    * is a subset of `List(('k', 1), ('o', 1))`.
    * It also include the empty subset `List()`.
    *
    * Example: the subsets of the occurrence list `List(('a', 2), ('b', 2))` are:
    *
    * List(
    * List(),
    * List(('a', 1)),
    * List(('a', 2)),
    * List(('b', 1)),
    * List(('a', 1), ('b', 1)),
    * List(('a', 2), ('b', 1)),
    * List(('b', 2)),
    * List(('a', 1), ('b', 2)),
    * List(('a', 2), ('b', 2))
    * )
    *
    * Note that the order of the occurrence list subsets does not matter -- the subsets
    * in the example above could have been displayed in some other order.
    */
def combinations(occurrences: Occurrences): List[Occurrences] = 
  occurrences.foldRight(List[Occurrences](Nil)) {
    case ((ch, occ), occAcc) => {
      for {
        oA <- occAcc
        count <- 1 to occ
      } yield (ch, count) :: oA
    } ++ occAcc
  }

/**返回事件列表的所有子集的列表。
*这包括事件本身，即`列表（（'k'，1），（'o'，1））`
*是`列表（（'k'，1），（'o'，1））`的子集。
*它还包括空子集'List（）`。
*
*示例：事件列表`列表（（'a'，2），（'b'，2））`的子集是：
*
*名单(
*列表（），
*列表（（'a'，1）），
*列表（（'a'，2）），
*列表（（'b'，1）），
*列表（（'a'，1），（'b'，1）），
*列表（（'a'，2），（'b'，1）），
*列表（（'b'，2）），
*列表（（'a'，1），（'b'，2）），
*列表（（'a'，2），（'b'，2））
* )
*
*请注意，出现列表子集的顺序并不重要——子集
*在上面的示例中，可以以其他顺序显示。
*/
def组合（引用：引用）：列出[引用]=
事件。foldRight（列表[事件]（无））{
案例（ch、occ、occAcc）=>{
为了{
oA我不知道这个
事件“类型”
及其结构是什么，但是当您传递事件列表时（不是指类型，例如List（'a'，2），它意味着字符“a”已经出现了两次，对不对？），它会将它们一个接一个地传递给
foldRight
函数，并作为初始值（零值是一个更好的术语），传递出现次数的空列表

，在第二个参数中传递接受和出现次数的匿名函数，该函数的字符表示为

ch

，当前出现次数表示为

occ

，而

occAcc

则表示出现次数的累加器，其余的都非常简单，它只是一个用于co的函数M了解对于occAcc中的每个元素和出现次数，会产生字符和可能出现的次数，并将其添加到最终结果中。

要深入理解，唯一的方法是把手弄脏，即在里面翻来翻去

输入一些诊断输出

def combinations(occurrences: Occurrences): List[Occurrences] =
  occurrences.foldRight(List[Occurrences](Nil)) {
    case ((ch, occ), occAcc) => {
      println(s"case (($ch, $occ), $occAcc) =>")  //<---
      for {
        oA <- occAcc
        count <- 1 to occ
        _ = println(s"yield ($ch,$count) :: $oA") //<---
      } yield (ch, count) :: oA
    } ++ occAcc
  }

val rslt = combinations(List(('a',2),('b',2)))    //build
println("------------")                           //separator
rslt.foreach(println)                             //results

def组合（引用：引用）：列表[引用]=
事件。foldRight（列表[事件]（无））{
案例（ch、occ、occAcc）=>{
println（s“case（$ch，$occ），$occAcc）=>”//输入是：List（（a，2），（b，2））这能回答你的问题吗？我想你不知道fold函数是做什么的，它需要一个元素列表，然后将元素折叠（聚合）成一个结果，例如，如果你想确定所有（整数）的和元素它可能类似于：
list.fold（0）{case（a，b）=>a+b}
，或者更简单：
list.fold（0）（\u+\ uu）
，在您的例子中，您使用的是foldRight，它在第二个参数中接收来自单个元组元素（ch，occ）的函数，另一个参数是累计器。让我们输入：list(（a，2），（b，2））。•步骤1:oA为空，计数为1。（b，1）被添加到列表oA中。然后另一个步骤（b，2）。这是我的第一个问题，现在发生了什么？步骤1:value（'a'，2）传递给occAcc=Nil的函数，对吗？让我们看看在中发生了什么，以便理解。occAcc仍然为空，因此它不会生成任何oA，在后面的行中，count生成1和2，对吗？查看作为结果的收益率返回：（'a'，1）和（'a'，2）被添加到occAcc列表中。在步骤2中，（'b'，2）是否传递给函数，为了理解，您有oA，它是occAcc（（'a'，1），（'a'，2））中的元素，对吗？计数生成为1和2（一次一个），收益率返回什么？（见下一条注释）它表示收益率，例如（'b'，1）到（'a'，1），到（'a'，2）到（'Nil）。然后将（'b'，2）添加到（'a'，1），（'a'，2），Nil中。因此，您的输出=>List（'a'，1），（'a'，2））是从第一次迭代生成的，连接到List（'b'，1），（'b'，2））。。。