Итерация IO действий и лень

Question

Я хотел бы написать Hangman https://github.com/fokot/reactive-hangman/blob/master/src/Hangman.hs с просмотром списка действий пользователя как ленивый поток. Мои рекурсивные версии работает нормально (в коде runGameRecursively (newGameState «секретно»))

я застрял на вопрос лени

updateGameState :: GameState -> IO GameState 
updateGameState gs = do 
    l <- getALetter gs 
    return $ updateState gs l 

ff :: (a -> Bool) -> [IO a] -> IO a 
ff f (i:is) = do 
    res <- i 
    if f res then return res else ff f is 

runGameInfinite :: GameState -> IO() 
runGameInfinite gs = 
    -- infinite lazy game loop 
    let repl = tail $ iterate (\x -> x >>= updateGameState) (return gs) :: [IO GameState] 
    in do 
    endState <- ff gameEnded repl 
    putStrLn $ showState endState 

main = runGameInfinite (newGameState "car") 

При запуске игры каждый шаг в РЕПЛ нужно пересмотреть все предыдущие, даже если они уже были. Я пытался играть с $! но не нашел правильного ответа, чтобы сделать это еще. Спасибо

Answer 1

Я думаю, что схема использования iterate, чтобы сделать якобы чистый список операций ввода-вывода, является источником проблемы здесь. Ваш план состоит в том, чтобы обновить состояние по пользовательскому вводу, но рассмотреть последовательность состояний как поток, который вы можете «обрабатывать как список». Если я использую подлинный iterateM для создания правильных потоков вещей, тогда все идет так, как вы хотели, чтобы они пошли. Так что, если я добавляю импорт

import Streaming -- cabal install streaming 
import qualified Streaming.Prelude as S 

и после ваших основных определений написать что-то вроде

runGameInfiniteStream gs = S.print $ S.take 1 $ S.dropWhile (not . gameEnded) steps 
    where 
    steps :: Stream (Of GameState) IO() 
    steps = S.iterateM updateGameState (return gs) 

main :: IO() 
main = runGameInfiniteStream (newGameState "car") 

тогда я получаю

>>> main 
You have 5 lifes. The word is "___" 
Guess a letter: 
c 
You have 5 lifes. The word is "c__" 
Guess a letter: 
a 
You have 5 lifes. The word is "ca_" 
Guess a letter: 
r 
GameState {secretWord = "car", lives = 5, guesses = "rac"} 

Я думаю, что это именно та программа, которую вы предназначены, но с использованием правильная концепция потока, а не смешивание IO и списков сложным способом. Нечто подобное можно было бы сделать с pipes и conduit и аналогичными пакетами.

---

(Добавлено позже :)

Для потоковой передачи в состояния, соответствующих чистый список символьного (эмуляции результата, вводимый пользователя), вы можете просто использовать scan

pureSteps 
    :: (Monad m) => GameState -> [Char] -> Stream (Of GameState) m() 
pureSteps gs chars = S.scan updateState gs id (S.each chars) 

это в основном такой же, как Prelude.scanl, который также может использоваться (в чистом виде) для просмотра обновлений:

>>> S.print $ pureSteps (newGameState "hi") "hxi" 
GameState {secretWord = "hi", lives = 5, guesses = ""} 
GameState {secretWord = "hi", lives = 5, guesses = "h"} 
GameState {secretWord = "hi", lives = 4, guesses = "h"} 
GameState {secretWord = "hi", lives = 4, guesses = "ih"} 

>>> mapM_ print $ scanl updateState (newGameState "hi") "hxi" 
GameState {secretWord = "hi", lives = 5, guesses = ""} 
GameState {secretWord = "hi", lives = 5, guesses = "h"} 
GameState {secretWord = "hi", lives = 4, guesses = "h"} 
GameState {secretWord = "hi", lives = 4, guesses = "ih"} 

Чтобы просмотреть окончательное «выигрывающее» состояние, если оно существует, вы можете написать, например.

runPureInfinite 
    :: Monad m => GameState -> [Char] -> m (Of [GameState]()) 
runPureInfinite gs = S.toList . S.take 1 . S.dropWhile (not . gameEnded) . pureSteps gs 

-- >>> S.print $ runPureInfinite (newGameState "car") "caxyzr" 
-- [GameState {secretWord = "car", lives = 2, guesses = "rac"}] :>() 

и так далее.