Question

我有这个相当简单的函数来计算大列表元素的平均值，使用两个累加器来保存到目前为止的总和以及到目前为止的计数：

mean = go 0 0
    where
      go s l []     = s / fromIntegral l
      go s l (x:xs) = go (s+x) (l+1) xs

main = do
  putStrLn (show (mean [0..10000000]))

现在，在严格的语言中，这将是尾递归的，并且没有问题。但是，由于Haskell很懒，我的谷歌搜索让我明白（s + x）和（l + 1）将作为thunk传递递归。所以整件事都会崩溃和烧伤：

Stack space overflow: current size 8388608 bytes.

进一步使用Google搜索后，我找到了seq和$!。这似乎我不理解，因为我在这种情况下使用它们的所有尝试都证明是徒劳的，错误信息说的是关于无限类型的东西。

最后我找到-XBangPatterns，通过更改递归调用来解决所有问题：

go !s !l (x:xs) = go (s+x) (l+1) xs

但我对此并不满意，因为-XBangPatterns目前是一个扩展。我想知道如何在不使用-XBangPatterns的情况下严格评估。（也许也可以学到一些东西！）

只是让你明白我缺乏理解，这就是我所尝试的（编译的唯一尝试，即）：

go s l (x:xs) = go (seq s (s+x)) (seq l (l+1)) xs

根据我的理解，seq应该强制评估s和l参数，从而避免由thunk引起的问题。但我仍然得到堆栈溢出。

Answer 1

我在这方面写了很多：

首先，是的，如果你想要对累加器进行严格评估，请使用seq并留在Haskell 98中：

mean = go 0 0
  where
    go s l []     = s / fromIntegral l
    go s l (x:xs) = s `seq` l `seq`
                      go (s+x) (l+1) xs

main = print $ mean [0..10000000]

*Main> main
5000000.0

其次：如果你给出一些类型注释，严格性分析将会启动，并使用-O2进行编译：

mean :: [Double] -> Double
mean = go 0 0
 where
  go :: Double -> Int -> [Double] -> Double
  go s l []     = s / fromIntegral l
  go s l (x:xs) = go (s+x) (l+1) xs

main = print $ mean [0..10000000]

$ ghc -O2 --make A.hs
[1 of 1] Compiling Main             ( A.hs, A.o )
Linking A ...

$ time ./A
5000000.0
./A  0.46s user 0.01s system 99% cpu 0.470 total

因为'Double'是严格原子类型Double＃的包装器，具有优化和精确类型，GHC运行严格性分析并推断严格版本可以。

import Data.Array.Vector

main = print (mean (enumFromToFracU 1 10000000))

data Pair = Pair !Int !Double

mean :: UArr Double -> Double   
mean xs = s / fromIntegral n
  where
    Pair n s       = foldlU k (Pair 0 0) xs
    k (Pair n s) x = Pair (n+1) (s+x)

$ ghc -O2 --make A.hs -funbox-strict-fields
[1 of 1] Compiling Main             ( A.hs, A.o )
Linking A ...

$ time ./A
5000000.5
./A  0.03s user 0.00s system 96% cpu 0.038 total

如上文RWH章节所述。

Answer 2

调用函数后，seq函数强制评估第一个参数。当您将seq s (s+x)作为参数传递时，seq函数立即被而不是调用，因为无需评估该参数的值。您希望在递归调用之前对seq的调用进行求值，以便反过来强制对其参数进行求值。

通常这样就完成了这个：

 go s l (x:xs) = s `seq` l `seq` go (s+x) (l+1) xs

这是seq s (seq l (go (s+x) (l+1) xs))的句法变体。这里对seq的调用是表达式中最外层的函数调用。由于Haskell的懒惰，这导致首先评估它们：使用仍然未评估的参数seq和s调用seq l (go (s+x) (l+1) xs)，评估参数被推迟到某人实际尝试访问的点他们的价值观。

现在seq可以在返回表达式的其余部分之前强制计算其第一个参数。然后评估的下一步将是第二步seq。如果对seq的调用被隐藏在某个参数的某个地方，它们可能会被执行很长时间，从而无法实现其目的。

使用seq s的更改位置，程序可以正常执行，而不会使用过多的内存。

该问题的另一个解决方案是在编译程序时（-O或-O2）简单地在GHC中启用优化。优化器识别可有可无的懒惰并产生不分配不必要内存的代码。

Answer 3

您的理解是seq s (s+x)强制对s进行评估。但它并没有强制s+x，因此你仍然在构建thunk。

通过使用$!，您可以强制评估添加（对于两个参数，两次）。这与使用爆炸模式的效果相同：

mean = go 0 0
 where
    go s l []     = s / fromIntegral l
    go s l (x:xs) = ((go $! s+x) $! l+1) xs

使用$!函数会将go $! (s+x)转换为相当于：

let y = s+x 
in seq y (go y)

因此y首先被强制进入弱头正常形式，这意味着应用了最外层的函数。在y的情况下，最外面的函数是+，因此y在传递给go之前完全评估为数字。

哦，你可能得到了无限类型的错误信息，因为你没有在正确的地方使用括号。我第一次写下你的程序时遇到了同样的错误： - ）

由于$!运算符是右关联的，因此没有括号go $! (s+x) $! (l+1)表示与go $! ((s+x) $! (l+1))相同，这显然是错误的。

Haskell中的懒惰和尾部递归，为什么会崩溃？

3 个答案: