0

我想练习IO在 Haskell 中使用 monad，所以我决定制作一个“屏幕保护程序”程序，它会在打印到控制台时无限递归。当代码运行时，控制台上不会出现任何内容。当我将它发送SIGTERM到程序时，它会打印硬编码的“概念证明”draw输出，但没有来自无限递归（go函数）的输出。

我怀疑这与惰性评估有关，go永远不会调用函数中输出到控制台的代码，但我不知道如何修复它。任何建议将不胜感激！

哈斯克尔代码：

import Data.Maybe (isJust, fromJust)
import System.Random
import System.Console.ANSI
import qualified System.Console.Terminal.Size as Term

data RainDrop a = RainDrop
  { row   :: !a
  , col   :: !a
  , count :: !a
  } deriving (Read,Show)

main :: IO ()
main = do
  clearScreen
  -- proof that draw works
  c <- applyX 10 draw (return (RainDrop 0 2 10))
  go [return (RainDrop 0 0 10)]

applyX :: Int -> (a -> a) -> a -> a
applyX 0 _ x = x
applyX n f x = applyX (n-1) f (f x)

go :: [IO (RainDrop Int)] -> IO ()
go []     = return ()
go (x:xs) = do
  prng <- newStdGen
  go $ map draw $ maybeAddToQueue prng (x:xs)

maybeAddToQueue :: RandomGen g => g -> [IO (RainDrop Int)] -> [IO (RainDrop Int)]
maybeAddToQueue _    []     = []
maybeAddToQueue prng (x:xs) =
  let
    (noNewDrop, gen0) = randomR (True,False) prng
  in
    if noNewDrop
    then x:xs
    else (
      do
        (colR,gen1) <- randomCol gen0
        return $ RainDrop 0 colR $ fst $ randomLen gen1
      ):x:xs

randomCol :: RandomGen g => g -> IO (Int, g)
randomCol prng = do
  w <- Term.size >>= (\x -> return . Term.width  $ fromJust x)
  return $ randomR (0,(w-1)) prng

randomLen :: RandomGen g => g -> (Int, g)
randomLen = randomR (4,32)

draw :: IO (RainDrop Int) -> IO (RainDrop Int)
draw rain = do
  x    <- rain
  prng <- newStdGen
  setCursorPosition (row x) (col x)
  putChar . toGlyph $ fst $ randomR range prng
  return (RainDrop (succ $ row x) (col x) (count x))

toGlyph x
 | isJust a  = fromJust a
 | otherwise = x
 where a = lookup x dictionary

dictionary =
  let (a,b) = range
  in zip [a..b] encoding

encoding =
  let (a,b) = splitAt 16 katakana
      (c,d) = splitAt 7  b
  in a ++ numbers ++ c ++ ['A'..'Z'] ++ d

range    = (' ','~')
katakana = ['･'..'ﾟ']
numbers  = "012Ƹ߈Ƽ6ߖȣ9"
4

3 回答 3

4

函数中的这一行go：

go $ map draw $ maybeAddToQueue prng (x:xs)

实际上并不执行任何 IO 动作——它只是从现有的 IO 动作中创建新的 IO 动作。

以下是我将如何解决问题的一些类型签名：

type World = [Raindrop]

-- draw the raindrops
draw :: World -> IO ()

-- advance the drops
step :: World -> World

-- add more drops
moreRain :: World -> IO (World)

-- the main loop
loop :: World -> IO ()
loop drops = do
  draw drops
  let drops' = step drops
  drops'' <- moreRain drops'
  -- delay for a while here???
  loop drops''

笔记：

  • 我已经声明step是一个纯函数，假设液滴的运动是确定性的
  • moreRain但是需要使用随机数生成器，所以是一个IO动作
于 2014-01-27T00:14:30.827 回答
1

作为一个粗略的一般规则：IO值通常应该只出现在功能箭头1的右侧。我不知道你已经阅读了多少关于 monads 的内容...... 值得一提的是 Haskell 对 monads 所做的事情是Kleisli 箭头比其他任何东西都多，所以典型的签名是形式A -> M B，带有“纯”A和B。

现在这并不能真正回答你的问题，但是如果你相应地重构你的程序（我想你还是想要练习）我怀疑它会起作用，所以我会这样离开它；你的代码对我来说有点太宽泛了，我负担不起详细阅读它的时间......

1当然，这条规则也有例外，实际上是一些非常重要的例外——通用动作组合器、循环等。但这些很少，并且已经在标准模块中定义Control.Monad。

于 2014-01-26T23:43:06.367 回答
0

go获取一个IO从未评估过的操作列表，因为您从不要求它们进行评估。对maybeAddToQueue. 相反，您可能希望随时评估它们。

您正在构建一个应该做某事的无限循环。您可能可以将其归结为forever someAction.

此外，您正在做所有事情，IO因此您可以使用IO随机函数的版本：

randomLen :: IO Int
randomLen = randomRIO (4,32)

首先修改draw：

draw :: RainDrop Int -> IO (RainDrop Int)
draw x = do
  setCursorPosition (row x) (col x)
  g <- randomRIO range
  putChar $ toGlyph g
  return (RainDrop (succ $ row x) (col x) (count x))

没有理由进行抽签，IO RainDrop因为无论如何您都会立即对其进行评估。

maybeAddToQueue :: [RainDrop Int] -> IO [RainDrop Int]
maybeAddToQueue [] = return []
maybeAddToQueue xs = do
  noNewDrop <- randomIO 
  if noNewDrop
  then return xs
  else do
        colR <- randomCol 
        len  <- randomLen 
        return $ (RainDrop 0 colR len):xs

最后，你的go功能：

go :: [RainDrop Int] -> IO ()
go [] = return ()
go a = do
   b <- maybeAddToQueue a
   c <- mapM draw b
   go c

或者，替代版本，这使得正在发生的事情变得更加清晰：

import Control.Monad ((>=>))

go = maybeAddToQueue >=> mapM draw >=> go

注意map变成了mapM. 这可以确保您的操作确实正在执行。由于从不要求列表的值，因此简单地使用map将永远不会评估列表的任何元素，因此IO从未运行任何操作。

于 2014-01-27T01:12:37.450 回答