Implicazioni di foldr vs. foldl (o foldl ')

Innanzitutto, Real World Haskell , che sto leggendo, dice di non usare mai foldle invece di usare foldl'. Quindi mi fido.

Ma io sono confusa su quando utilizzare foldrvs. foldl'. Anche se riesco a vedere la struttura di come funzionano in modo diverso davanti a me, sono troppo stupido per capire quando "che è meglio". Immagino mi sembri che non dovrebbe davvero importare quale sia usato, dato che entrambi producono la stessa risposta (no?). In effetti, la mia precedente esperienza con questo costrutto è quella di Ruby injecte Clojure reduce, che non sembrano avere versioni "sinistra" e "destra". (Domanda a margine: quale versione usano?)

Qualsiasi intuizione che possa aiutare un tipo sfidato intelligente come me sarebbe molto apprezzata!

La ricorsione per foldr f x ysdove ys = [y1,y2,...,yk]appare

f y1 (f y2 (... (f yk x) ...))

mentre la ricorsione per foldl f x yssembra

f (... (f (f x y1) y2) ...) yk

Una differenza importante qui è che se il risultato di f x ypuò essere calcolato usando solo il valore di x, allora foldrnon è necessario esaminare l'intero elenco. Per esempio

foldr (&&) False (repeat False)

ritorna Falsementre

foldl (&&) False (repeat False)

non termina mai. (Nota: repeat Falsecrea un elenco infinito in cui si trova ogni elementoFalse .)

D'altra parte, la foldl'coda è ricorsiva e severa. Se sai che dovrai attraversare l'intero elenco, non importa cosa (ad es. Sommare i numeri in un elenco), allora foldl'è più efficiente nello spazio (e probabilmente nel tempo) di foldr.

foldr Somiglia a questo:

foldl Somiglia a questo:

Contesto: piega sul wiki di Haskell

La loro semantica differisce quindi non puoi semplicemente scambiare foldlefoldr . L'uno piega gli elementi da sinistra, l'altro da destra. In questo modo, l'operatore viene applicato in un ordine diverso. Questo è importante per tutte le operazioni non associative, come la sottrazione.

Haskell.org ha un interessante articolo sull'argomento.

In breve, foldrè meglio quando la funzione accumulatore è pigra sul suo secondo argomento. Maggiori informazioni su Stack Overflow di Haskell wiki (gioco di parole).

Il motivo foldl'è preferitofoldl 99% di tutti gli usi è che può essere eseguita in uno spazio costante per la maggior parte degli usi.

Prendi la funzione sum = foldl['] (+) 0. Quando foldl'viene utilizzata, la somma viene immediatamente calcolata, quindi l'applicazione suma un elenco infinito verrà eseguita per sempre, e molto probabilmente nello spazio costante (se stai usando cose come Ints, Doubles, Floats. IntegerS userai più dello spazio costante se il il numero diventa maggiore dimaxBound :: Int ).

Con foldl, viene creato un thunk (come una ricetta su come ottenere la risposta, che può essere valutata in seguito, anziché memorizzare la risposta). Questi thunk possono occupare molto spazio e, in questo caso, è molto meglio valutare l'espressione piuttosto che archiviare il thunk (portando a un overflow dello stack ... e portandoti a ... oh, non importa)

Spero che aiuti.

A proposito, Ruby injecte Clojure reducesono foldl(o foldl1, a seconda della versione che usi). Di solito, quando esiste una sola forma in una lingua, si tratta di una piega a sinistra, tra cui Python reduce, Perl List::Util::reduce, C ++ accumulate, C # Aggregate, Smalltalk inject:into:, PHP array_reduce, Mathematica Fold, ecc. Le reduceimpostazioni predefinite comuni di Lisp a piega a sinistra, ma c'è un'opzione per la piega a destra.

Come sottolinea Konrad , la loro semantica è diversa. Non hanno nemmeno lo stesso tipo:

ghci> :t foldr
foldr :: (a -> b -> b) -> b -> [a] -> b
ghci> :t foldl
foldl :: (a -> b -> a) -> a -> [b] -> a
ghci> 

Ad esempio, l'operatore di aggiunta elenco (++) può essere implementato con foldras

(++) = flip (foldr (:))

mentre

(++) = flip (foldl (:))

ti darà un errore di tipo.