differenza tra piega Sinistra e Riduci Sinistra in Scala

Ho imparato la differenza di base tra foldLeftereduceLeft

foldLeft:

• il valore iniziale deve essere passato

reduceLeft:

• accetta il primo elemento della raccolta come valore iniziale
• genera un'eccezione se la raccolta è vuota

C'è qualche altra differenza?

Qualche motivo specifico per avere due metodi con funzionalità simili?

Poche cose da menzionare qui, prima di dare la risposta effettiva:

• La tua domanda non ha nulla a che fare con left, riguarda piuttosto la differenza tra ridurre e piegare
• La differenza non è affatto l'implementazione, basta guardare le firme.
• La domanda non ha nulla a che fare con Scala in particolare, riguarda piuttosto i due concetti di programmazione funzionale.

Torna alla tua domanda:

Ecco la firma di foldLeft(potrebbe anche essere stato foldRightper il punto che farò):

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

Ed ecco la firma di reduceLeft(di nuovo la direzione non conta qui)

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

Questi due sembrano molto simili e quindi hanno causato confusione. reduceLeftè un caso speciale di foldLeft(che a proposito significa che a volte puoi esprimere la stessa cosa usando uno di essi).

Quando chiami reduceLeftsay su a List[Int], ridurrà letteralmente l'intero elenco di numeri interi in un singolo valore, che sarà di tipo Int(o un supertipo di Int, quindi [B >: A]).

Quando chiami foldLeftdire su un List[Int], piegherà l'intero elenco (immagina di arrotolare un pezzo di carta) in un singolo valore, ma questo valore non deve essere nemmeno correlato a Int(quindi [B]).

Ecco un esempio:

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

Questo metodo accetta a List[Int]e restituisce a Tuple2[List[Int], Int]o (List[Int], Int). Calcola la somma e restituisce una tupla con un elenco di numeri interi ed è la somma. A proposito, l'elenco viene restituito al contrario, perché abbiamo usato al foldLeftposto di foldRight.

Guarda One Fold per domarli tutti per una spiegazione più approfondita.

reduceLeftè solo un metodo pratico. È equivalente a

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

foldLeftè più generico, puoi usarlo per produrre qualcosa di completamente diverso da quello che hai inserito in origine. Considerando che reduceLeftpuò solo produrre un risultato finale dello stesso tipo o super tipo del tipo di raccolta. Per esempio:

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

Il foldLeftapplicherà la chiusura con l'ultimo risultato ripiegato (prima volta con valore iniziale) e il valore successivo.

reduceLeftd'altra parte combinerà prima due valori dall'elenco e li applicherò alla chiusura. Successivamente combinerà il resto dei valori con il risultato cumulativo. Vedere:

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

Se l'elenco è vuoto, è foldLeftpossibile presentare il valore iniziale come risultato legale. reduceLeftd'altra parte non ha un valore legale se non riesce a trovare almeno un valore nell'elenco.

La ragione principale per cui si trovano entrambi nella libreria standard Scala è probabilmente perché si trovano entrambi nella libreria standard Haskell (chiamata foldle foldl1). In caso reduceLeftcontrario, sarebbe spesso definito come un metodo di praticità in diversi progetti.

Per riferimento, si reduceLeftverificherà un errore se applicato a un contenitore vuoto con il seguente errore.

java.lang.UnsupportedOperationException: empty.reduceLeft

Rielaborazione del codice da utilizzare

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

è un'opzione potenziale. Un altro è quello di utilizzare la reduceLeftOptionvariante che restituisce un risultato a capo Opzione.

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

Dai principi di programmazione funzionale in Scala (Martin Odersky):

La funzione reduceLeftè definita in termini di una funzione più generale, foldLeft.

foldLeftè come reduceLeftma accetta un accumulatore z , come parametro aggiuntivo, che viene restituito quando foldLeftviene chiamato in un elenco vuoto:

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

[al contrario reduceLeft, che genera un'eccezione quando viene chiamato in un elenco vuoto.]

Il corso (vedi lezione 5.5) fornisce definizioni astratte di queste funzioni, che illustrano le loro differenze, sebbene siano molto simili nel loro uso di pattern matching e ricorsione.

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

Nota che foldLeftrestituisce un valore di tipo U, che non è necessariamente lo stesso tipo di List[T], ma riduciLeft restituisce un valore dello stesso tipo dell'elenco).

Per capire davvero cosa stai facendo con fold / ridurre, controlla questo: http://wiki.tcl.tk/17983 ottima spiegazione. una volta ottenuto il concetto di piega, ridurre si unirà alla risposta sopra: list.tail.foldLeft (list.head) (_)