Кратко и по делу.

Проблема

В Haskell вычисления по умолчанию ленивые. При использовании
sum1 xs = foldl (+) 0 xs накапливается цепочка отложенных вычислений (thunks), примерно вида
(((0 + x_1) + x_2) + \dots + x_n),
но эти выражения не вычисляются по шагам — они накапливаются в памяти и будут вычислены только в конце. Это приводит к росту памяти (space leak) и к потере производительности (создание/хранение большого числа thunks, возможный выход за память).

Почему так происходит

foldl лево‑свёртывает, но оставляет аккумулятор ленивым: каждый шаг возвращает новый thunk вместо уже вычисленного значения аккумулятора. Даже если операция вроде (+) по сути строгая, сам вызов (+) с невычисленными аргументами порождает thunk, который удерживает ссылки на предыдущие элементы, мешая сборщику мусора.

Пример последствий

sum1 [1..10000000] может потреблять много памяти и быть медленным;foldl подходит для случаев, где вы хотите сохранить ленивость аккумулятора (редко нужно).

Как правильно — жадные версии и стратегии

Используйте foldl' из Data.List (или Data.Foldable) — она форсирует аккумулятор в WHNF на каждом шаге и предотвращает накопление thunks:

sum2 xs = foldl' (+) 0 xsВнутренне приблизительно:
foldl' f !z [] = z
foldl' f !z (x:xs) = foldl' f (f z x) xsЭто обычно даёт постоянную дополнительную память для аккумулятора (O(1)) и заметное ускорение.

Если foldl' невозможна, можно вручную форсировать аккумулятор через seq:

f' acc x = let acc' = f acc x in acc' `seq` acc'

или с BangPatterns:

{-# LANGUAGE BangPatterns #-}
fold' f !z [] = z
fold' f !z (x:xs) = fold' f (f z x) xs

Для агрегатов с несколькими полями — используйте строгие поля в типах (!) или форсируйте каждое поле отдельно, иначе thunk будет внутри структуры.

Для больших/параллельных сумм: рассматривайте foldMap + Monoid (позволяет оптимизации и параллелизм), или специализированные строгие контейнеры.

Ограничения и альтернативы

Жёсткая стратегия теряет преимущества ленивости: foldl' не работает с бесконечными списками или если вам нужна ленивость/короткое замыкание. Для таких случаев используют foldr или ленивые комбинации (foldr + (:) для построения списков).foldr хорош для ленивого потребления/производства результатов и для коротких замыканий, но не для строгой инкрементальной аккумуляции больших списков.

Практические советы

Для простого суммирования и других накопительных операций по большим спискам — почти всегда foldl'.Если вы складываете сложные структуры — делайте поля строгими или форсируйте их через seq/deepseq.Не полагайтесь на тонкие оптимизации компилятора: явная строгая версия (foldl', seq, BangPatterns, строгие поля) более надёжна.Профилируйте (heap/retainer profiling), чтобы локализовать space leak — иногда причина не в foldl, а в удержании списка/других ссылок.

Итого: ленивость может привести к накоплению thunks и space leak при использовании foldl. Используйте foldl' или явную строгую стратегию (seq/BangPatterns/строгие поля) для строгой аккумуляции; применяйте foldr/ленивость там, где нужна ленивость или работа с бесконечными потоками.