Hello,
I'm trying to use a sequence of timeoutAdd's in a gtk2hs app. By
sequence, I mean one (IO Bool) must return as False before the next
begins:
timeoutSeq [ (fn1, 100), (fn2, 200) ]
fn1 will keep running every 100, until it returns False. Then fn2 will
get a timeoutAdd 200, and so on...
First attempt (works fine, I think):
timeoutSeq :: [(IO Bool, Int)] -> IO ()
timeoutSeq [] = return ()
timeoutSeq ((fn,n):rest) = do
timeoutAdd (aux fn rest) n
return ()
where
aux :: IO Bool -> [(IO Bool, Int)] -> IO Bool
aux fn [] = fn
aux fn lst = do
r <- fn
case r of
True -> return True
False -> do
timeoutSeq lst
return False
Now, I'd like to write a timeoutDep (fn1, n1) (fn2, n2) where fn1 and
fn2 are both running at their respective rates, and fn1 will run only
as long as fn2 is running. The use case for this is eg: Run fn1 often
and fn2 less often, but I only care fn1 to be running as long as fn2
is still valid.
timeoutDep (fn,n) (fn2,n2) = do
hdl <- timeoutAdd fn n
timeoutSeq [(aux fn2 hdl, n2), (return False, 100)]
where
aux fn2 hdl = do
r <- fn2
case r of
True -> return True
False -> do
timeoutRemove hdl
return False
This implementation sort of works, except it exits immiediately (and
as IO ()), so I can't for example do this:
timeoutSeq [((timeoutDep (print "a" >> return True, 100)
(print "b" >> return
True, 100)), 100)
, (print "c" >> return False, 100)]
Ths silly example should keep printing 'a' and 'b' w/o ever printing
'c'. Any ideas or suggestions?
