Zbieranie danych wyjściowych IO na listę

Question

W jaki sposób można wywoływać wiele połączeń z numerem SDL.pollEvent :: IO Event, aż do uzyskania wyniku SDL.NoEvent i zebrać wszystkie wyniki na liście?

w kategoriach nadrzędnych coś takiego:

events = [] 
event = SDL.pollEvent 
while (event != SDL.NoEvent) { 
     events.add(event) 
     event = SDL.pollEvent 
} 

Answer 1

James Cook był tak uprzejmy, aby przedłużyć monad-loop S z tej funkcji:

unfoldWhileM :: Monad m => (a -> Bool) -> m a -> m [a] 

stosować SDL:

events <- unfoldWhileM (/= SDL.NoEvent) SDL.pollEvent 

Answer 2

Można użyć monadycznego list:

import Control.Monad.ListT (ListT) 
import Control.Monad.Trans.Class (lift) -- transformers, not mtl 
import Data.List.Class (takeWhile, repeat, toList) 
import Prelude hiding (takeWhile, repeat) 

getEvents :: IO [Event] 
getEvents = 
    toList . takeWhile (/= NoEvent) $ do 
     repeat() 
     lift pollEvent :: ListT IO Event 

ListT z "listy" pakiet na hackage.

Answer 3

Można użyć coś takiego:

 
takeWhileM :: (a -> Bool) -> IO a -> IO [a] 
takeWhileM p act = do 
    x <- act 
    if p x 
    then do 
     xs <- takeWhileM p act 
     return (x : xs) 
    else 
     return [] 

zamiast:

do 
    xs <- takeWhileM p act 
    return (x : xs) 

można również użyć:

liftM (x:) (takeWhileM p act) otrzymując:

 
takeWhileM :: (a -> Bool) -> IO a -> IO [a] 
takeWhileM p act = do 
    x <- act 
    if p x 
    then liftM (x:) (takeWhileM p act) 
    else return [] 

Następnie można użyć : takeWhileM (/=SDL.NoEvent) SDL.pollEvent

Answer 4

I w końcu potknął się o tym fragmencie kodu w rzeczywistej grze SDL z hackage

getEvents :: IO Event -> [Event] -> IO [Event] 
getEvents pEvent es = do 
    e <- pEvent 
    let hasEvent = e /= NoEvent 
    if hasEvent 
    then getEvents pEvent (e:es) 
    else return (reverse es) 

btw dzięki za odpowiedzi!

Answer 5

Stosując te odcinki dla Event i pollEvent

data Event = NoEvent | SomeEvent 
    deriving (Show,Eq) 

instance Random Event where 
    randomIO = randomRIO (0,1) >>= return . ([NoEvent,SomeEvent] !!) 

pollEvent :: IO Event 
pollEvent = randomIO 

i COMBINATOR, pożyczone i adaptacją an earlier answer, że przestaje oceny po raz pierwszy orzecznik zawiedzie

spanM :: (Monad m) => (a -> Bool) -> m a -> m [a] 
spanM p a = do 
    x <- a 
    if p x then do xs <- spanM p a 
       return (x:xs) 
     else return [x] 

Pozwala to sesja ghci, dla przykład:

*Main> spanM (/= NoEvent) pollEvent 
[SomeEvent,SomeEvent,NoEvent]