haskell - 为什么 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