为什么每次迭代 putStrLn 都会变慢？

Question

我制作了一个小型的生命游戏程序，它自己迭代几代。问题是每次迭代时， putStrLn 函数都会显着减慢，我无法弄清楚原因。这是代码：

import Control.Concurrent

data CellState = Dead | Alive

data Position = Position Integer Integer

type Generation = Position -> CellState

is_alive :: CellState -> Bool
is_alive Alive = True
is_alive Dead = False

neighbors :: Position -> [Position]
neighbors (Position x y) =
  [(Position (x-1) (y-1)), (Position x (y-1)),  (Position (x+1) (y-1)), (Position (x+1) y),
  (Position (x+1) (y+1)), (Position x (y+1)), (Position (x-1) (y+1)), (Position (x-1) y)]

alive_neighbors :: Generation -> Position -> Int
alive_neighbors generation position = length (filter is_alive (map generation (neighbors position)))

evolution :: Generation -> Generation
evolution generation position =
  case (alive_neighbors generation position) of
  2 -> if (is_alive (generation position)) then Alive else Dead
  3 -> Alive
  _ -> Dead

visualize_generation generation = map (visualize_line generation) [1..10]

visualize_line :: Generation -> Integer -> String
visualize_line generation y = concat (map (visualize_cell generation y) [1..10])

visualize_cell generation y x =
  case (generation (Position x y)) of
  Alive -> ['0']
  Dead -> ['.']

{-
bar (Position 1 2) = Alive
bar (Position 2 3) = Alive
bar (Position 3 3) = Alive
bar (Position 3 2) = Alive
bar (Position 3 1) = Alive
bar (Position x y) = Dead
-}

bar (Position 1 3) = Alive
bar (Position 2 3) = Alive
bar (Position 3 3) = Alive
bar (Position x y) = Dead

life :: Generation -> IO ()
life bar_ = do cls
               mapM_ putStrLn (visualize_generation bar_)
               threadDelay 1000000 
               life (evolution bar_)

cls = putStr "\ESC[2J"

我最初期望每一代出于某种原因也会计算所有前几代，但似乎并非如此。如果是这种情况，我希望进化函数的计算时间会增加，而不是 putStrLn 函数打印缓慢。关于是什么让 putStrLn 函数在每一代中减慢这么多的任何想法？

Answer 1

（免责声明：这只是一个猜测，我可能是错的。我没有进行实验来证实这一点。）

这是使用函数来表示网格所要付出的代价

type Generation = Position -> CellState

这是一种表示状态的优雅方式，但从长远来看，效率并不高。当你的算法运行时，它会创建很多闭包：

generation0 = \position -> ....
generation1 = \position -> .... use generation0
generation2 = \position -> .... use generation1
generation3 = \position -> .... use generation2
...

即使你只需要上一代，所有上一代的数据仍然保存在内存中，因为它被上一代（间接）使用。因此，您永远不会释放内存，这已经很糟糕了。

更糟糕的是，每次使用 generation 时N，这将N-1多次调用 generation N-2(8)，然后多次调用 generation (8)，依此类推，直到 generation 0。这会导致指数爆炸。

要解决此问题，您需要将数据表示更改为更有效的方式。我认为一些类似矩阵的类型可以工作。