Question

考虑以下功能：

(<.>) :: [[a]] -> [[a]] -> [[a]]
xs <.> ys = zipWith (++) xs ys

这实际上是由a的两个二维数组组成，并从左到右，例如：

[[1,2],[3,4]] <.> [[1,2],[3,4]] == [[1,2,1,2],[3,4,3,4]]

我希望能够编写如下内容：

x = foldr1 (<.>) $ repeat [[1,2],[3,4]]

由于Haskell的懒惰评估，这应该是有道理的，也就是说，我们应该获得：

x !! 0 == [1,2,1,2,1,2,1,2...]
x !! 1 == [3,4,3,4,3,4,3,4...]

但是，当我尝试使用foldr1或foldl1在GHCi上运行此示例时，我得到的是非终止计算或堆栈溢出。

所以我的问题是：

这是怎么回事？
是否可以使用foldr1或foldl1以外的其他功能来完成我要完成的任务？（如果我需要修改<.>的实现，我很高兴，只要它能计算出相同的功能即可）

另外，请注意：我知道在此示例中，map repeat [[1,2],[3,4]]会产生所需的输出，但是我正在寻找一种适用于任意无限列表的解决方案，而不仅仅是{{1}形式的那些}。

Answer 1

我将在这里评论中的内容进行扩展。我将借用GHC version of zipWith（简化版本）lazy patterns，对于本次讨论来说应该足够了。

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith f [] _ = []
zipWith f _ [] = []
zipWith f (x:xs) (y:ys) = f x y : zipWith f xs ys

现在，这就是您的计算最终的样子，它是光荣的无限形式。

[[1, 2], [3, 4]] <.> ([[1, 2], [3, 4]] <.> ([[1, 2], [3, 4]] ... ) ... )

好的，所以顶层是<.>。精细。让我们仔细看看。

zipWith (++) [[1, 2], [3, 4]] ([[1, 2], [3, 4]] <.> ([[1, 2], [3, 4]] ... ) ... )

仍然没有问题。现在我们来看看zipWith的模式。第一个模式仅在左侧为空时匹配。威尔普，那绝对不是真的，所以让我们继续吧。仅当右侧为空时，第二个匹配。因此，让我们看看右侧是否为空。右侧看起来像

[[1, 2], [3, 4]] <.> ([[1, 2], [3, 4]] <.> ([[1, 2], [3, 4]] ... ) ... )

我们从这开始。因此，要计算结果，我们需要访问结果。因此，堆栈溢出。

现在，我们已经确定问题出在zipWith上。因此，让我们一起玩吧。首先，我们知道我们将在人为的示例中将其应用于无限列表，因此我们不需要那种令人讨厌的空列表大小写。摆脱它。

-- (I'm also changing the name so we don't conflict with the Prelude version)
zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' f (x:xs) (y:ys) = f x y : zipWith' f xs ys

(<.>) :: [[a]] -> [[a]] -> [[a]]
xs <.> ys = zipWith' (++) xs ys

但是那不能解决任何问题。我们仍然必须评估弱头范式（读取：列表中的数字为空）以匹配该模式。

如果只有一种方法可以进行模式匹配而不必去WHNF ...，请输入{{3}}。让我们用这种方式重写我们的函数。

zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' f ~(x:xs) ~(y:ys) = f x y : zipWith' f xs ys

现在，如果给出有限列表，我们的函数将绝对中断。但这使我们可以“假装”列表上的模式匹配而无需实际进行任何工作。相当于更加冗长

zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' f xs ys = f (head xs) (head ys) : zipWith' f (tail xs) (tail ys)

现在我们可以正确测试您的功能了。

*Main> let x = foldr1 (<.>) $ repeat [[1, 2], [3, 4]]
*Main> x !! 0
[1,2,1,2,1,2,1,2,1,...]
*Main> x !! 1
[3,4,3,4,3,4,3,4,3,...]

这样做的明显缺点是，它肯定会在有限列表上失败，因此您必须对它们具有不同的功能。

*Main> [[1, 2], [3, 4]] <.> [[1, 2], [3, 4]]
[[1,2,1,2],[3,4,3,4],*** Exception: Prelude.head: empty list

Answer 2

zipWith并不是（实际上不可能）像您想要的那样懒惰。在您的示例中考虑以下变化：

GHCi> foldr1 (zipWith (++)) [ [[1,2],[3,4]], [] ]
[]

输入中任何空列表列表将导致结果列表为空列表。既然如此，在消耗完整个输入之前，您将无法知道结果的任何元素。因此，您的函数不会在无限列表上终止。

Silvio Mayolo's answer针对此问题进行了一些可能的解决方法。我的建议是使用列表的非空列表，而不是列表的普通列表：

GHCi> import qualified Data.List.NonEmpty as N
GHCi> import Data.List.NonEmpty (NonEmpty(..))
GHCi> take 10 . N.head $ foldr1 (N.zipWith (++)) $ repeat ([1,2] :| [[3,4]])
[1,2,1,2,1,2,1,2,1,2]

N.zipWith doesn't have to deal with an empty list case，所以它可能更懒。

折叠无限列表时堆栈溢出？

2 个答案: