सूची में आईओ आउटपुट एकत्रित करना

Question

आउटपुट पर एकाधिक कॉल कैसे जारी कर सकता है जब तक कि आउटपुट SDL.NoEvent न हो और सभी परिणामों को एक सूची में एकत्र करें?

जरूरी संदर्भ में कुछ इस तरह:

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

Answer 1

जेम्स कुक इसलिए इस समारोह के साथ monad-loop रों विस्तार करने के लिए तरह था:

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

Answer 2

आप monadic सूचियों का उपयोग कर सकते हैं:

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 

hackage पर "सूची" पैकेज से ListT।

 
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 [] 

के बजाय

:

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

आप भी उपयोग कर सकते हैं:

liftM (x:) (takeWhileM p act) उपज:

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

तो आप उपयोग कर सकते

Answer 3

आप की तरह कुछ इस्तेमाल कर सकते हैं : takeWhileM (/=SDL.NoEvent) SDL.pollEvent

Answer 4

मैं अंत में btw अपने जवाब के लिए 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) 

धन्यवाद से एक वास्तविक एसडीएल खेल में इस कोड स्निपेट से अधिक ठोकर खाई!

Answer 5

इस GHCi सत्र Event के लिए इन स्टब्स और pollEvent

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

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

pollEvent :: IO Event 
pollEvent = randomIO 

और एक Combinator, उधार ली गई और an earlier answer से अनुकूलित का उपयोग करना, कि पहली बार विधेय में विफल रहता है

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] 

का मूल्यांकन बंद हो जाता है की अनुमति देता है, के लिए उदाहरण:

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