Implicações de foldr vs. foldl (ou foldl ')

Em primeiro lugar, o Mundo Real Haskell , que estou lendo, diz para nunca usar foldle usar foldl'. Então eu confio nisso.

Mas eu sou vago sobre quando usar foldrvs. foldl'. Embora eu possa ver a estrutura de como eles funcionam de maneira diferente na minha frente, sou burra demais para entender quando "o que é melhor". Acho que me parece que realmente não deveria importar o que é usado, pois ambos produzem a mesma resposta (não é?). De fato, minha experiência anterior com esse construto é de Ruby injecte Clojure reduce, que não parecem ter versões "esquerda" e "direita". (Pergunta secundária: qual versão eles usam?)

Qualquer insight que possa ajudar um tipo de smarts desafiado como eu seria muito apreciado!

A recursão para foldr f x ysonde ys = [y1,y2,...,yk]parece

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

Considerando que a recursão para foldl f x ysparece

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

Uma diferença importante aqui é que, se o resultado de f x ypuder ser calculado usando apenas o valor de x, foldrnão será necessário examinar a lista inteira. Por exemplo

foldr (&&) False (repeat False)

retorna Falseenquanto

foldl (&&) False (repeat False)

nunca termina. (Nota: repeat Falsecria uma lista infinita onde cada elemento está False.)

Por outro lado, foldl'é cauda recursiva e rigorosa. Se você souber que terá que percorrer a lista inteira, não importa o que (por exemplo, somar os números em uma lista), foldl'será mais eficiente em termos de espaço (e provavelmente de tempo) foldr.

foldr se parece com isso:

foldl se parece com isso:

Contexto: dobre no wiki Haskell

Sua semântica é diferente, então você não pode simplesmente trocar foldle foldr. Um dobra os elementos da esquerda e o outro da direita. Dessa forma, o operador é aplicado em uma ordem diferente. Isso é importante para todas as operações não associativas, como subtração.

Haskell.org tem um artigo interessante sobre o assunto.

Em breve, foldré melhor quando a função acumulador é preguiçosa em seu segundo argumento. Leia mais em Stack Overflow do wiki da Haskell (trocadilhos).

O motivo foldl'preferido foldlpara 99% de todos os usos é que ele pode ser executado em espaço constante para a maioria dos usos.

Tome a função sum = foldl['] (+) 0. Quando foldl'é usada, a soma é calculada imediatamente; portanto, a aplicação suma uma lista infinita será executada para sempre e provavelmente no espaço constante (se você estiver usando coisas como Ints, Doubles, Floats. IntegerS usará mais do que o espaço constante se o número fica maior que maxBound :: Int).

Com foldl, um thunk é construído (como uma receita de como obter a resposta, que pode ser avaliada mais tarde, em vez de armazenar a resposta). Esses thunks podem ocupar muito espaço e, nesse caso, é muito melhor avaliar a expressão do que armazenar o thunk (causando um estouro de pilha… e levando você a… oh, não importa)

Espero que ajude.

A propósito, Ruby injecte Clojure reducesão foldl(oufoldl1 , dependendo da versão que você usa). Normalmente, quando existe apenas um formulário em uma linguagem, é uma dobra à esquerda, incluindo Python reduce, Perl List::Util::reduce, C ++ accumulate, C # Aggregate, Smalltalk inject:into:, PHP array_reduce, Mathematica Fold, etc. O reducepadrão do Common Lisp é o padrão para a esquerda, mas há uma opção para a direita.

Como Konrad aponta, sua semântica é diferente. Eles nem têm o mesmo tipo:

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

Por exemplo, o operador de adição de lista (++) pode ser implementado com foldro seguinte

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

enquanto

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

lhe dará um erro de tipo.