Haskell 空间使用编译时间限制

Question

我很喜欢 Haskell，但空间泄漏对我来说有点担心。我通常认为 Haskell 的类型系统比 C++ 更安全，但是使用 C 风格的循环我可以相当肯定它会在不耗尽内存的情况下完成，而 Haskell 的“折叠”可能会耗尽内存，除非你小心适当的字段是严格的。

我想知道是否有一个库使用 Haskell 类型系统来确保可以编译和运行各种结构，而不会产生 thunk。例如，no_thunk_fold 会抛出编译器错误，如果使用它的方式可能会产生 thunk。我知道这可能会限制我可以做的事情，但我想要一些我可以使用的功能作为一个选项，这会让我更有信心我没有不小心在某个地方留下一个重要的非严格字段并且我会用完空间。

Answer 1

听起来您担心惰性求值的某些不利方面。你想确保你的折叠、循环、递归在常量内存中处理。

创建的迭代库解决了这个问题， pipes, conduit, enumerator, iteratee, iterIO.

最受欢迎和最近的是 pipes 和 conduit。两者都超出了迭代模型。

pipes 库专注于理论上的合理性，以努力消除错误并允许设计的恒常性打开高效但高水平的抽象（我的话不是作者）。如果需要，它还提供双向流，这是迄今为止该库独有的优势。

conduit 的理论基础不如管道那么好，但它的巨大优势是目前在其上构建了更多用于解析和处理 http 流、xml 流等的相关库。查看包装页面上hackage 的导管部分。它被使用 yesod Haskell 较大且知名的 Web 框架之一。

我很喜欢使用管道库编写流媒体应用程序，特别是能够制作代理转换器堆栈。当我需要获取网页或解析一些 xml 时，我一直在使用管道库。

我还应该提到 io-streams 刚刚完成了 first official release。它的目标特别是 IO，它的名字并不奇怪，并且使用更简单的类型机制，更少的类型参数，然后 pipes 或 conduit。主要的缺点是你被困在 IO monad 中，所以它对纯代码没有多大帮助。

{-# language NoMonoMorphismRestriction #-}                                       
import Control.Proxy

从简单的翻译开始。

map (+1) [1..10]

变成：

runProxy $ mapD (+1) <-< fromListS [1..10]

迭代者喜欢为简单的翻译提供更详细的内容，但通过更大的示例提供更大的胜利。

一个代理管道库的示例，它以常量空间生成斐波那契数

fibsP = runIdentityK $ (\a -> do respond 1                                       
                                 respond 1                                       
                                 go 1 1)                                         
  where                                                                          
    go fm2 fm1 = do  -- fm2, fm1 represents fib(n-2) and fib(n-1)                                                            
        let fn = fm2 + fm1                                                       
        respond fn -- sends fn downstream                                                              
        go fm1 fn

这些可以流式传输到标准输出 runProxy $ fibsP >-> printD -- printD 只打印下游值，代理是管道包的双向提供。

您应该查看proxy tutorial 和conduit tutorial，我刚刚发现它们现在在 FP Complete 的 Haskell 学校。

一种求均值的方法是：

> ((_,l),s) <- (`runStateT` 0) $ (`runStateT` 0) $ runProxy $  foldlD' ( flip $ const (+1)) <-< raiseK (foldlD' (+)) <-< fromListS [1..10::Int]
> let m = (fromIntegral . getSum) s / (fromIntegral . getSum) l
5.5

现在添加地图或过滤代理很容易。

> ((_,l),s) <- (`runStateT` 0) $ (`runStateT` 0) $ runProxy $  foldlD' ( flip $ const (+1)) <-< raiseK (foldlD' (+)) <-< filterD even <-< fromListS [1..10::Int]

编辑：重写代码以利用状态单子。

更新：

在博文beautiful folding 中演示了以可比较的方式对大量数据流进行多次计算的更多方法，然后编写直接递归。折叠转换为数据并在使用严格累加器时组合。我没有定期使用这种方法，但它似乎确实隔离了需要严格性的地方，使其更容易应用。您还应该查看answer to another question similar question，它使用 applicative 实现了相同的方法，并且可能更容易阅读，具体取决于您的偏好。

Answer 2

Haskell 的类型系统不能做到这一点。我们可以用一个完全多态的术语来证明这一点，以吃掉任意数量的 ram。

takeArbitraryRAM :: Integer -> a -> a
takeArbitraryRAM i a = last $ go i a where
  go n x | n < 0 = [x]
  go n x | otherwise = x:go (n-1) x

做你想做的事需要substructural types。线性逻辑对应于 lambda 演算的一个高效可计算片段（尽管您还需要控制递归）。添加结构公理可以让您花费超指数时间。

Haskell 允许您伪造线性类型，以便使用索引单子来管理某些资源。不幸的是，空间和时间都融入了语言，所以你不能为他们这样做。您可以按照评论中的建议进行操作，并使用 Haskell DSL 生成具有性能限制的代码，但此 DSL 中的计算项可能会花费任意时间并使用任意空间。

不用担心空间泄漏。抓住他们。轮廓。证明复杂性界限的代码的原因。无论您使用哪种语言，您都必须这样做。