在无限列表上左右折叠

我对“了解您的Haskell”（很棒的书imo，不要轻描淡写）中的以下文章有疑问：

一个很大的不同是，右折叠在无限列表上起作用，而左折叠则不行！简而言之，如果您在某个时间点取一个无限的列表，然后将其从右侧折叠起来，最终您将到达列表的开头。但是，如果您在某个点取一个无限的列表，然后尝试将其从左向上折叠，那么您将永远无法结束！

我就是不明白这一点。如果您获取一个无限列表，然后尝试从右侧将其折叠起来，那么您将不得不从无穷大的那一点开始，这只是没有发生（如果有人知道您可以使用的语言，请告诉：p ）。至少，您必须根据Haskell的实现从那里开始，因为在Haskell foldr和foldl中，不需要使用确定在列表中应该从何处开始折叠的参数。

我同意报价单iff foldr和foldl的参数确定了它们应该在列表中的何处开始折叠，因为有意义的是，如果您从无限的列表开始并从已定义的索引开始折叠，它将最终终止，而实际上不管你从左折开始 您将向无限折叠。但是，foldr和foldl不接受此参数，因此引号没有意义。在Haskell中，无限列表上的左折和右折都不会终止。

我的理解正确吗？还是我缺少什么？

这里的关键是懒惰。如果用于折叠列表的函数很严格，则给定无限列表，向左折叠或向右折叠都不会终止。

Prelude> foldr (+) 0 [1..]
^CInterrupted.

但是，如果尝试折叠不太严格的功能，则会得到终止结果。

Prelude> foldr (\x y -> x) 0 [1..]
1

您甚至可以得到一个无限数据结构的结果，因此尽管它在某种意义上不会终止，但仍然可以产生可以延迟使用的结果。

Prelude> take 10 $ foldr (:) [] [1..]
[1,2,3,4,5,6,7,8,9,10]

但是，这不适用于foldl，因为您将永远无法评估最外部的函数调用，无论是否延迟。

Prelude> foldl (flip (:)) [] [1..]
^CInterrupted.
Prelude> foldl (\x y -> y) 0 [1..]
^CInterrupted.

请注意，左右折页之间的关键区别不是列表的遍历顺序（总是从左到右），而是嵌套的结果函数应用程序的顺序。

• 使用foldr，它们嵌套在“内部”

  foldr f y (x:xs) = f x (foldr f y xs)
  

  在这里，第一次迭代将导致的最外层应用f。因此，f有机会变得懒惰，以便不总是对第二个参数进行求值，或者第二个参数可以在不强制第二个参数的情况下产生数据结构的某些部分。

• 使用foldl，它们嵌套在“外部”

  foldl f y (x:xs) = foldl f (f y x) xs
  

  在这里，我们无法评估任何事物，直到我们达到的最外层应用为止f，而对于无限列表而言，无论f严格与否，我们都无法达到。

关键词是“在某个时候”。

如果您在某个时间点取了一个无限列表，然后从右侧向上折叠，最终将到达列表的开头。

因此，您是对的，您不可能从无限列表的“最后一个”元素开始。但是作者的观点是：假设可以。只需在远处选择一个点（对于工程师来说，这“足够接近”到无穷大）并开始向左折叠。最终，您最终在列表的开头。对于左折，情况并非如此，如果您在那儿选择一个点waaaay（并将其称为“足够接近”到列表的开头），然后向右开始折叠，那么您还有无限的路要走。

因此，诀窍在于，有时您无需达到无穷大。您可能甚至不需要在那里走走。但是您可能不知道需要走多远，在这种情况下，无限列表非常方便。

简单的例子是foldr (:) [] [1..]。让我们进行折叠。

回想一下foldr f z (x:xs) = f x (foldr f z xs)。在无限列表上，实际上什么都没关系，z所以我只是保留它z而不是[]使插图混乱

foldr (:) z (1:[2..])         ==> (:) 1 (foldr (:) z [2..])
1 : foldr (:) z (2:[3..])     ==> 1 : (:) 2 (foldr (:) z [3..])
1 : 2 : foldr (:) z (3:[4..]) ==> 1 : 2 : (:) 3 (foldr (:) z [4..])
1 : 2 : 3 : ( lazily evaluated thunk - foldr (:) z [4..] )

看看foldr，尽管理论上是从右折起，但在这种情况下，实际上是如何从左侧开始将结果列表中的各个元素分解出来的？因此，如果您take 3从此列表中可以清楚地看到，它将能够生产[1,2,3]并且无需进一步评估折痕。

请记住，在Haskell中，由于延迟计算，您可以使用无限列表。因此，即使`[1 ..]无限长，head [1..]也只是1和head $ map (+1) [1..]2。如果没有得到，请停下来玩一会儿。如果您明白了，请继续阅读...

我觉得你的困惑的部分是，foldl和foldr总是从一侧或另一侧开始，因此您无需花太多时间。

foldr 有一个非常简单的定义

 foldr _ z [] = z
 foldr f z (x:xs) = f x $ foldr f z xs

为什么这会在无限列表上终止，请尝试

 dumbFunc :: a -> b -> String
 dumbFunc _ _ = "always returns the same string"
 testFold = foldr dumbFunc 0 [1..]

在这里，我们传入foldr“”（因为值无关紧要）和自然数的无限列表。这会终止吗？是。

它终止的原因是因为Haskell的评估等同于惰性术语重写。

所以

 testFold = foldr dumbFunc "" [1..]

变为（允许模式匹配）

 testFold = foldr dumbFunc "" (1:[2..])

与（根据我们对fold的定义）相同

 testFold = dumbFunc 1 $ foldr dumbFunc "" [2..]

现在，根据dumbFunc我们的定义，我们可以得出结论

 testFold = "always returns the same string"

当我们具有执行某些功能但有时很懒的功能时，这会更有趣。例如

foldr (||) False 

用于查找列表是否包含任何True元素。我们可以使用它来定义高阶函数any，True当且仅当传入的函数对于列表的某些元素为true时，该函数才返回

any :: (a -> Bool) -> [a] -> Bool
any f = (foldr (||) False) . (map f)

关于懒惰的评价的好处，就是当它遇到这将停止的第一元素e，使得f e == True

另一方面，并​​非如此foldl。为什么？foldl看起来真的很简单

foldl f z []     = z                  
foldl f z (x:xs) = foldl f (f z x) xs

现在，如果我们尝试上面的示例会发生什么

testFold' = foldl dumbFunc "" [1..]
testFold' = foldl dumbFunc "" (1:[2..])

现在变成：

testFold' = foldl dumbFunc (dumbFunc "" 1) [2..]

所以

testFold' = foldl dumbFunc (dumbFunc (dumbFunc "" 1) 2) [3..]
testFold' = foldl dumbFunc (dumbFunc (dumbFunc (dumbFunc "" 1) 2) 3) [4..]
testFold' = foldl dumbFunc (dumbFunc (dumbFunc (dumbFunc (dumbFunc "" 1) 2) 3) 4) [5..]

等等等等。我们永远无法到达任何地方，因为Haskell总是首先评估最外部的函数（简而言之就是惰性评估）。

这样的一个很酷的结果是，您可以实现foldl，foldr但反之则不能。这意味着以某种深刻的方式foldr是所有高阶字符串函数中最基础的，因为它是我们用来实现几乎所有其他函数的函数。您仍然可能需要使用foldl有时候，因为您可以foldl递归实现tail，并从中获得一些性能提升。

Haskell Wiki上有很好的解释。它显示了使用不同类型的折叠和累加器功能的逐步还原。

您的理解是正确的。我想知道作者是否正在尝试谈论Haskell的惰性评估系统（在该系统中，您可以将无限列表传递给不包括fold的各种函数，并且它将仅评估返回答案所需的内容）。但是我同意您的观点，即作者在描述该段中的内容时做得不好，并且说错了。