Question

我一直在尝试在Haskell中编码一个需要使用大量可变引用的算法，但与纯粹的惰性代码相比，它（可能并不奇怪）非常慢。考虑一个非常简单的例子：

module Main where

import Data.IORef
import Control.Monad
import Control.Monad.Identity

list :: [Int]
list = [1..10^6]

main1 = mapM newIORef list >>= mapM readIORef >>= print
main2 = print $ map runIdentity $ map Identity list

在我的机器上运行GHC 7.8.2，main1需要1.2秒并使用290MB内存，而main2仅需0.4秒并且仅使用1MB。是否有任何阻止这种增长的技巧，特别是在太空？对于非IORef的非原始类型，我经常需要Int s，并且假设IORef会像常规thunk一样使用额外的指针，但我的直觉似乎是错误的。< / p>

我已经尝试了一个带解压缩IORef的专用列表类型，但没有显着差异。

Answer 1

这很可能不是关于IORef，而是关于严格性。 IO monad中的操作是串行的 - 所有先前的操作必须在下一个操作开始之前完成。所以

mapM newIORef list

在读取任何内容之前生成一百万IORef个。

然而，

map runIdentity . map Identity
= map (runIdentity . Identity)
= map id

流非常好，所以我们print列表中的一个元素，然后生成下一个元素等。

如果您想要更公平的比较，请使用严格的map：

map' :: (a -> b) -> [a] -> [b]
map' f [] = []
map' f (x:xs) = (f x:) $! map' f xs

Answer 2

问题在于你使用mapM，它在时间和空间上总是在大型列表上表现不佳。正确的解决方案是使用mapM_和(>=>)：

来融合中间列表

import Data.IORef
import Control.Monad

list :: [Int]
list = [1..10^6]

main = mapM_ (newIORef >=> readIORef >=> print) list

它在恒定的空间内运行并提供出色的性能，在我的机器上运行0.4秒。

编辑：在回答您的问题时，您也可以使用pipes执行此操作，以避免手动融合循环：

import Data.IORef
import Pipes
import qualified Pipes.Prelude as Pipes

list :: [Int]
list = [1..10^6]

main = runEffect $
    each list >-> Pipes.mapM newIORef >-> Pipes.mapM readIORef >-> Pipes.print

这在我的机器上以大约0.7秒的恒定空间运行。

Answer 3

我发现解决问题的方法是使用惰性mapM代替，定义为

lazyMapM :: (a -> IO b) -> [a] -> IO [b]
lazyMapM f [] = return []
lazyMapM f (x:xs) = do
  y <-  f x
  ys <- unsafeInterleaveIO $ lazyMapM f xs
  return (y:ys)

这允许monadic版本在相同的1MB和相似的时间内运行。我希望懒惰的ST monad可以更优雅地解决这个问题而不使用unsafeInterleaveIO作为函数：

main = print $ runST (mapM (newSTRef) list >>= mapM (readSTRef))

但这不起作用（你还需要使用unsafeInterleaveST），这让我想到Control.Monad.ST.Lazy实际上是多么懒惰。有人知道吗？：）

Haskell：IORefs的表现

3 个答案: