Implications de foldr vs foldl (ou foldl ')

Premièrement, Real World Haskell , que je lis, dit de ne jamais utiliser foldlet d'utiliser à la place foldl'. Alors je lui fais confiance.

Mais je suis brumeux quand utiliser foldrcontre foldl'. Bien que je puisse voir la structure de leur fonctionnement différemment présentée devant moi, je suis trop stupide pour comprendre quand «ce qui est mieux». Je suppose qu'il me semble que peu importe ce qui est utilisé, car ils produisent tous les deux la même réponse (n'est-ce pas?). En fait, mon expérience précédente avec cette construction vient de Ruby injectet Clojure reduce, qui ne semblent pas avoir de versions «gauche» et «droite». (Question secondaire: quelle version utilisent-ils?)

Toute perspicacité qui peut aider une sorte intelligente comme moi serait très appréciée!

La récursivité pour foldr f x ysoù ys = [y1,y2,...,yk]ressemble

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

alors que la récursivité pour foldl f x ysressemble à

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

Une différence importante ici est que si le résultat de f x ypeut être calculé en utilisant uniquement la valeur de x, il foldrn'est pas nécessaire d'examiner la liste entière. Par exemple

foldr (&&) False (repeat False)

retourne Falsealors que

foldl (&&) False (repeat False)

ne se termine jamais. (Remarque: repeat Falsecrée une liste infinie où se trouve chaque élément False.)

D'autre part, la foldl'queue est récursive et stricte. Si vous savez que vous devrez parcourir toute la liste quoi qu'il arrive (par exemple, additionner les nombres dans une liste), alors foldl'est plus efficace en termes d'espace (et probablement de temps) que foldr.

foldr ressemble à ça:

foldl ressemble à ça:

Contexte: plier sur le wiki Haskell

Leur sémantique diffère donc vous ne pouvez pas simplement échanger foldlet foldr. L'un replie les éléments par la gauche, l'autre par la droite. De cette façon, l'opérateur est appliqué dans un ordre différent. Ceci est important pour toutes les opérations non associatives, telles que la soustraction.

Haskell.org a un article intéressant sur le sujet.

En bref, foldrc'est mieux lorsque la fonction d'accumulateur est paresseuse sur son deuxième argument. Pour en savoir plus, consultez Stack Overflow de Haskell wiki (jeu de mots).

La raison foldl'est préférée foldlpour 99% de toutes les utilisations est qu'il peut fonctionner dans un espace constant pour la plupart des utilisations.

Prenez la fonction sum = foldl['] (+) 0. Quand foldl'est utilisé, la somme est immédiatement calculée, donc l'application sumà une liste infinie ne fonctionnera que pour toujours, et très probablement dans un espace constant (si vous utilisez des choses comme Ints, Doubles, Floats. IntegerS utilisera plus qu'un espace constant si le nombre devient supérieur à maxBound :: Int).

Avec foldl, un bruit sourd est construit (comme une recette sur la façon d'obtenir la réponse, qui peut être évaluée plus tard, plutôt que de stocker la réponse). Ces thunks peuvent prendre beaucoup de place, et dans ce cas, il vaut mieux évaluer l'expression que de stocker le thunk (conduisant à un débordement de pile… et vous conduisant à… oh tant pis)

J'espère que cela pourra aider.

À propos, Ruby injectet Clojure reducesont foldl(ou foldl1, selon la version que vous utilisez). Habituellement, quand il n'y a qu'une seule forme dans un langage, c'est un pli gauche, y compris celui de Python reduce, Perl List::Util::reduce, C ++ accumulate, C # Aggregate, Smalltalk inject:into:, PHP array_reduce, Mathematica Fold, etc. Common Lisp est par reducedéfaut le pli gauche mais il y a une option pour le pli droit.

Comme le souligne Konrad , leur sémantique est différente. Ils n'ont même pas le même type:

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

Par exemple, l'opérateur d'ajout de liste (++) peut être implémenté avec foldras

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

tandis que

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

vous donnera une erreur de type.