Scala中foldLeft和reduceLeft的区别

Question

我已经了解了 foldLeft 和 reduceLeft 之间的基本区别

foldLeft:

• 必须传递初始值

reduceLeft:

• 首先采用 作为初始值的集合元素
• 如果集合为空，

会引发异常还有其他区别吗？

有什么具体原因让两种方法具有相似的功能？

Answer 1

它们都在 Scala 标准库中的根本原因可能是因为它们都在 Haskell 标准库中（称为 foldl 和 foldl1）。如果 reduceLeft 不是，它通常会在不同的项目中被定义为一种方便的方法。

Answer 2

来自 Scala 函数式编程原则 (Martin Odersky)：

函数reduceLeft是根据更通用的函数foldLeft定义的。

foldLeft 与 reduceLeft 类似，但采用累加器 z 作为附加参数，当foldLeft 在空列表上调用：

（列表（x1，...，xn）foldLeft z）（op）=（...（z op x1）op ...）op x

[相对于reduceLeft，在空列表上调用时会引发异常。]

该课程（参见讲座 5.5）提供了这些函数的抽象定义，这说明了它们的差异，尽管它们在模式的使用上非常相似匹配和递归。

abstract class List[T] { ...
  def reduceLeft(op: (T,T)=>T) : T = this match{
    case Nil     => throw new Error("Nil.reduceLeft")
    case x :: xs => (xs foldLeft x)(op)
  }
  def foldLeft[U](z: U)(op: (U,T)=>U): U = this match{
    case Nil     => z
    case x :: xs => (xs foldLeft op(z, x))(op)
  }
}

请注意，foldLeft 返回一个 U 类型的值，该值不一定与 List[T] 类型相同，但 reduceLeft 返回一个值与列表类型相同）。

Answer 3

要真正了解您在使用折叠/减少做什么，
检查这个：http://wiki.tcl.tk/17983
很好的解释。一旦你掌握了折叠的概念，
减少将与上面的答案一起：
list.tail.foldLeft(list.head)(_)

Answer 4

Scala 2.13.3，演示：

val names = List("Foo", "Bar")
println("ReduceLeft: "+ names.reduceLeft(_+_))
println("ReduceRight: "+ names.reduceRight(_+_))
println("Fold: "+ names.fold("Other")(_+_))
println("FoldLeft: "+ names.foldLeft("Other")(_+_))
println("FoldRight: "+ names.foldRight("Other")(_+_))

输出：

ReduceLeft: FooBar
ReduceRight: FooBar
Fold: OtherFooBar
FoldLeft: OtherFooBar
FoldRight: FooBarOther

Answer 5

在给出实际答案之前，这里要提一下：

• 您的问题与 left 没有任何关系，而是关于减少和折叠之间的区别。
• 区别根本不在于实现，而在于看看签名。
• 这个问题与 Scala 没有任何关系，而是关于函数式编程的两个概念。

回到你的问题：

这是 foldLeft 的签名（也可以是 foldRight 来表达我要表达的观点）

def foldLeft [B] (z: B)(f: (B, A) => B): B

：这是 reduceLeft 的签名（这里方向并不重要）

def reduceLeft [B >: A] (f: (B, A) => B): B

这两个看起来非常相似，因此引起了混乱。 reduceLeft 是 foldLeft 的特例（顺便说一句，这意味着您有时可以使用它们中的任何一个来表达相同的内容）。

当您在 List[Int] 上调用 reduceLeft 时，它实际上会将整个整数列表减少为单个值，该值的类型为 Int （或 Int 的超类型，因此 [B >: A]）。

当您在 List[Int] 上调用 foldLeft 时，它会将整个列表（想象一下卷起一张纸）折叠成单个值，但该值不会折叠甚至必须与Int相关（因此是[B]）。

下面是一个示例：

def listWithSum(numbers: List[Int]) = numbers.foldLeft((List.empty[Int], 0)) {
   (resultingTuple, currentInteger) =>
      (currentInteger :: resultingTuple._1, currentInteger + resultingTuple._2)
}

此方法采用 List[Int] 并返回 Tuple2[List[Int], Int] 或 (List[Int], Int ）。它计算总和并返回一个包含整数列表及其总和的元组。顺便说一下，列表是向后返回的，因为我们使用了 foldLeft 而不是 foldRight。

观看一折统治一切以获得更深入的解释。

Answer 6

reduceLeft 只是一个方便的方法。它相当于

list.tail.foldLeft(list.head)(_)

Answer 7

foldLeft 更通用，您可以使用它来生成与最初放入的内容完全不同的内容。而 reduceLeft 只能生成相同类型或超类型的最终结果的集合类型。例如：

List(1,3,5).foldLeft(0) { _ + _ }
List(1,3,5).foldLeft(List[String]()) { (a, b) => b.toString :: a }

foldLeft 将应用最后折叠结果（第一次使用初始值）和下一个值的闭包。

另一方面，reduceLeft 将首先组合列表中的两个值并将它们应用于闭包。接下来它将把其余的值与累积结果结合起来。请参阅：

List(1,3,5).reduceLeft { (a, b) => println("a " + a + ", b " + b); a + b }

如果列表为空，foldLeft 可以将初始值呈现为合法结果。另一方面，如果 reduceLeft 在列表中找不到至少一个值，则它没有合法值。

Answer 8

作为参考，如果应用于空容器，reduceLeft 将出错并出现以下错误。

java.lang.UnsupportedOperationException: empty.reduceLeft

重新编写要使用的代码

myList foldLeft(List[String]()) {(a,b) => a+b}

是一种潜在的选择。另一种方法是使用 reduceLeftOption 变体，它返回 Option 包装的结果。

myList reduceLeftOption {(a,b) => a+b} match {
  case None    => // handle no result as necessary
  case Some(v) => println(v)
}