在haskell中执行严格的问题

Question

如果想假装 Haskell 是严格的并且我有一个算法不利用惰性（例如它不使用无限列表），如果我只使用会出现什么问题严格的数据类型并注释我使用的任何函数，使其参数严格？是否会有性能损失，如果有，有多糟糕；会出现更严重的问题吗？我知道盲目地让每个函数和数据类型变得严格是肮脏、毫无意义和丑陋的，我不打算在实践中这样做，但我只想了解如果这样做，Haskell 默认会变得严格吗？

其次，如果我淡化这种偏执，只对数据结构进行严格的处理：只有在我使用某种形式的累加时，我才需要担心由惰性实现引起的空间泄漏 ?换句话说，假设该算法在严格的语言中不会出现空间泄漏。还假设我在 Haskell 中使用 only 严格的数据结构实现了它，但是小心地使用 seq 来评估在递归中传递的任何变量，或者使用内部小心执行该操作的函数（如折叠'），我会避免任何空间泄漏吗？请记住，我假设在严格的语言中，相同的算法不会导致空间泄漏。所以这是一个关于lazy和strict的实现区别的问题。

我问第二个问题的原因是因为除了试图通过使用惰性数据结构或脊椎严格的数据结构来利用惰性的情况之外，我到目前为止看到的所有空间泄漏示例，只涉及在累加器中开发的 thunk，因为它不是递归调用的函数，在将自身应用于累加器之前没有评估累加器。我知道，如果一个人想利用懒惰，那么必须格外小心，但在默认情况下严格的语言中也需要这种谨慎。

谢谢。

Answer 1

懒惰加快了速度

你可能会更糟。 ++ 的朴素定义是：

xs ++ ys = case xs of (x:xs) -> x : (xs ++ ys)
                      []     -> ys

懒惰使这个 O(1)，尽管它也可能添加 O(1) 处理来提取缺点。如果没有惰性，++ 需要立即进行评估，从而导致 O(n) 操作。 （如果你从未见过 O(.) 表示法，那是计算机科学从工程师那里偷来的东西：给定一个函数 f 集合 O( f(n) ) 是所有算法的集合，最终是最差的-与f(n)成比例，其中n是输入函数的位数。[形式上，存在k和N，因此对于所有n > N，算法采用时间小于k * f(n)。] 所以我说懒惰使上述操作O(1) 或最终恒定时间，但为每次提取增加了恒定开销，而严格性使操作@ 987654333@ 或最终与列表元素的数量呈线性关系，假设这些元素具有固定大小。

这里有一些实际示例，但是 O(1) 增加的处理时间也可能“叠加”成 O(n) 依赖项，因此最明显的示例是 O(n² ） 双向。这些示例中仍然存在差异。例如，一种效果不佳的情况是使用堆栈（后进先出，这是 Haskell 列表的样式）作为队列（先进先出）。

所以这是一个包含严格左折叠的快速库；我使用了 case 语句，以便每一行都可以粘贴到 GHCi 中（使用 let）：

data SL a = Nil | Cons a !(SL a) deriving (Ord, Eq, Show)
slfoldl' f acc xs = case xs of Nil -> acc; Cons x xs' -> let acc' = f acc x in acc' `seq` slfoldl' f acc' xs'
foldl' f acc xs = case xs of [] -> acc; x : xs' -> let acc' = f acc x in acc' `seq` foldl' f acc' xs'
slappend xs ys = case xs of Nil -> ys; Cons x xs' -> Cons x (slappend xs' ys)
sl_test n = foldr Cons Nil [1..n]
test n = [1..n]
sl_enqueue xs x = slappend xs (Cons x Nil)
sl_queue = slfoldl' sl_enqueue Nil
enqueue xs x = xs ++ [x]
queue = foldl' enqueue []

这里的技巧是queue 和sl_queue 都遵循xs ++ [x] 模式将一个元素附加到列表的末尾，这需要一个列表并构建该列表的精确副本。然后 GHCi 可以运行一些简单的测试。首先，我们制作两个项目并强制他们的 thunk 来证明这个操作本身非常快并且在内存中太过于昂贵：

*Main> :set +s
*Main> let vec = test 10000; slvec = sl_test 10000
(0.02 secs, 0 bytes)
*Main> [foldl' (+) 0 vec, slfoldl' (+) 0 slvec]
[50005000,50005000]
(0.02 secs, 8604632 bytes)

现在我们进行实际测试：对队列版本求和：

*Main> slfoldl' (+) 0 $ sl_queue slvec
50005000
(22.67 secs, 13427484144 bytes)
*Main> foldl' (+) 0 $ queue vec
50005000
(1.90 secs, 4442813784 bytes)

请注意，这两个在内存性能方面都很糟糕（列表附加的东西仍然秘密地是 O(n²)），它们最终占用了千兆字节空间，但严格的版本却占用了三倍的空间和十倍的时间。

有时应该更改数据结构

如果您真的想要一个严格的队列，有几个选择。一个是手指树，就像Data.Sequence 一样——viewr 他们做事的方式有点复杂，但可以获取最右边的元素。然而，这有点繁重，一个常见的解决方案是 O(1) 摊销：定义结构

data Queue x = Queue !(SL x) !(SL x)

SL 术语是上面的严格堆栈。定义一个严格的reverse，我们称之为slreverse，显而易见的方式，然后考虑：

enqueue :: Queue x -> x -> Queue x
enqueue (Queue xs ys) el = Queue xs (Cons el ys)

dequeue :: Queue x -> Maybe (x, Queue x)
dequeue (Queue Nil Nil) = Nothing
dequeue (Queue Nil (Cons x xs)) = Just (x, Queue (slreverse xs) Nil)
dequeue (Queue (Cons x xs ys)) = Just (x, Queue xs ys)

这是“摊销 O(1)”：每次dequeue 反转列表，花费一些 k 的 O(k) 步，我们确保我们正在创建一个不需要的结构为k 更多步骤支付这些费用。

懒惰隐藏错误

另一个有趣的点来自数据/余数据的区别，其中数据是通过子单元递归遍历的有限结构（即每个数据表达式都停止），而余数据是其余结构——严格列表与流。事实证明，当你正确地做出这种区分时，严格数据和惰性数据之间没有形式上的区别——严格和惰性数据之间唯一形式上的区别是它们如何处理自身内部无限循环的术语： strict 会探索循环，因此也会无限循环，而lazy 会简单地继续执行无限循环，而不深入其中。

因此，您会发现 x = slhead (Cons x undefined) 将在 head (x : undefined) 成功的地方失败。因此，当您执行此操作时，您可能会“发现”隐藏的无限循环或错误。

“一切都严格”时要小心

当您在您的语言中使用严格的数据结构时，并非所有内容都必须变得严格：请注意，我在上面指出了为列表和严格列表定义严格的foldl，而不是foldl。 Haskell 中的常见数据结构将是惰性的——列表、元组、流行库中的东西——以及对 seq 的显式调用仍然有助于构建复杂的表达式。