恒定空间中的一元折叠

Question

如何在恒定空间中使用一元动作折叠惰性列表？我要解决的问题是聚合一个大文件，我相信为了性能，我需要可变性。我有一个使用可变向量在 ST 中工作的实现，但它使用了太多内存。下面是我正在尝试的一个例子。我还对 Conduit 进行了短暂的试验，但似乎没有任何改进。

ST forM_：

import Control.Monad (forM_)
import Control.Monad.ST.Trans as STT
import Control.Monad.Identity as Identity

testST :: Int
testST = do
  Identity.runIdentity $ STT.runST $ do
    a <- STT.newSTRef 0
    forM_ [1..10000000] (\x -> do
        a' <- STT.readSTRef a
        STT.writeSTRef a (a' + x)
      )
    STT.readSTRef a

导管：

import Data.Conduit (($=),(=$),($$))
import qualified Data.Conduit as C
import qualified Data.Conduit.List as CL

testCL :: IO Int
testCL = CL.sourceList [1..10000000] $$ CL.foldM (\a x -> return (a + x)) 0

Answer 1

问题不在于折叠，而在于折叠体。这个程序分配很多：

testST = runST $ do
    ref <- newSTRef 0
    forM_ [1..10000000] $ \x -> do
         val <- readSTRef ref
         writeSTRef ref (val + x)
    readSTRef ref

这个程序，唯一的区别是writeSTRef 行，几乎没有分配：

testST = runST $ do
    ref <- newSTRef 0
    forM_ [1..10000000] $ \x -> do
        val <- readSTRef ref
        writeSTRef ref $! val + x
    readSTRef ref

两段代码之间的差异很好地暗示了正在发生的事情：在前者中，您正在创建对具有 10000000 层应用程序 + 的深层嵌套 thunk 的引用；而后者在每一步都会压平thunk。

顺便说一下，这个常见的陷阱是explicitly called out in the documentation for modifySTRef。