为什么 foldr' 不如 foldl' 严格？

Question

考虑一下这些不同的尝试，比如last：

Prelude> import Data.Foldable
Prelude Data.Foldable> foldr const undefined (reverse [1,2,3])
3
Prelude Data.Foldable> foldr' const undefined (reverse [1,2,3])
3
Prelude Data.Foldable> foldl (flip const) undefined [1,2,3]
3
Prelude Data.Foldable> foldl' (flip const) undefined [1,2,3]
*** Exception: Prelude.undefined
CallStack (from HasCallStack):
  error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err
  undefined, called at <interactive>:5:21 in interactive:Ghci4

foldl 和 foldr 都可以工作，因为它们的累加器并不严格，对我来说很有意义，foldl' 没有，因为确实如此。但是为什么foldr' 有效？它的累加器不应该也很严格吗？

Answer 1

作为参考，实例Foldable [] 覆盖foldr、foldl、foldl'，但不是foldr' (source)：

instance Foldable [] where
    elem    = List.elem
    foldl   = List.foldl
    foldl'  = List.foldl'
    foldl1  = List.foldl1
    foldr   = List.foldr
    {- ... -}

foldr' 默认定义为 (source)：

foldr' :: (a -> b -> b) -> b -> t a -> b
foldr' f z0 xs = foldl f' id xs z0
  where f' k x z = k $! f x z

注意f的结果只有一个严格的注解。所以初始累加器不是强制的。

这表明了一个不同的实现，它确实强制累加器：

foldr'' :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldr'' f = foldr (\x z -> f x $! z)

（已编辑：以前的版本专门用于列表。）

我不知道为什么选择一个而不是另一个。大概是疏忽， 并且foldr' 不使用Foldable [] 实例中的默认实现会更加一致。

---

顺便说一句，foldl' 的默认定义也与列表中的定义相同：

-- Default (class Foldable t where ...)
foldl' :: (b -> a -> b) -> b -> t a -> b
foldl' f z0 xs = foldr f' id xs z0
  where f' x k z = k $! f z x

-- List implementation
foldl'           :: forall a b . (b -> a -> b) -> b -> [a] -> b
foldl' k z0 xs =
  foldr (\(v::a) (fn::b->b) -> oneShot (\(z::b) -> z `seq` fn (k z v))) (id :: b -> b) xs z0