diferencia entre foldLeft y reduceLeft en Scala

reduceLeft es solo un método de conveniencia. Es equivalente a

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

foldLeft es más genérico, puedes usarlo para producir algo completamente diferente a lo que originalmente pusiste. Mientras que reduceLeft solo puede producir un resultado final del mismo tipo o super tipo del tipo de colección. Por ejemplo:

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

El foldLeft aplicará el cierre con el último resultado plegado (la primera vez usando el valor inicial) y el siguiente valor.

reduceLeft por otro lado, primero combinará dos valores de la lista y los aplicará al cierre. A continuación se combinará el resto de los valores con el resultado acumulativo. Véase:

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

Si la lista está vacía foldLeft puede presentar el valor inicial como un resultado legal. reduceLeft por otro lado no tiene un valor legal si no puede encontrar al menos un valor en la lista.

Como referencia, reduceLeft se producirá un error si se aplica a un contenedor vacío con el siguiente error.

java.lang.UnsupportedOperationException: empty.reduceLeft

Reelaborar el código para usar

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

Es una opción potencial. Otra es usar la variante reduceLeftOption que devuelve un resultado envuelto en una opción.

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

La razón básica por la que ambos están en la biblioteca estándar de Scala es probablemente porque ambos están en la biblioteca estándar de Haskell (llamada foldl y foldl1). Si reduceLeft no lo fuera, a menudo se definiría como un método de conveniencia en diferentes proyectos.

De Principios de Programación Funcional en Scala (Martin Odersky):

La función reduceLeft se define en términos de una función más general, foldLeft.

foldLeft es como {[1] } pero toma un acumulador z, como parámetro adicional, que se devuelve cuando se llama a foldLeft en una lista vacía:

(List (x1, ..., xn) foldLeft z)(op) = (...(z op x1) op ...) op x

[a diferencia de reduceLeft, que lanza una excepción cuando se llama en una lista vacía.]

El curso (ver conferencia 5.5) proporciona definiciones abstractas de estas funciones, lo que ilustra sus diferencias, aunque son muy similares en su uso de coincidencia de patrones y recursión.

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)
  }
}

Tenga en cuenta que foldLeft devuelve un valor de tipo U, que no es necesariamente el mismo tipo que List[T], pero reduceLeft devuelve un valor del mismo tipo que la lista).

Para entender realmente qué estás haciendo con fold / reduce, compruebe esto: http://wiki.tcl.tk/17983 muy buena explicación. una vez que obtengas el concepto de plegado, reducir vendrá junto con la respuesta anterior: lista.cola.foldLeft (list.head) (_)