For a university seminar I’m currently writing a GUI program to view fractals based on simple iterated function systems (only similaritudes allowed). It supports three different drawing algorithms and you can edit the IFS by dragging squares around on the screen. But this post is not about this program (I might present it later), but how Haskell allowed me to solve a problem very nicely:

The first instances of the code had a problem that a lot of GUI programmers know: The drawing of the fractal took quite some time, and during that time the gtk main loop is blocked and the program becomes unresponsive. At first I avoided this problem by manually splitting the drawing function (e.g. by repeatedly increasing the resolution) and kept re-drawing it at higher resolutions in an idle handler, so at least I could interact whenever one resolution has finished drawing. It worked somewhat but it was not easily done for the other, not pixel based, algorithms and it was ugly.

So I wanted a way to (a) pause the drawing at any convenient point, to resume it later, and (b) safely abort the drawing if what I’m drawing has changed and I need to restart.

A common solution to this would be to do the drawing in a separate thread, so (a) is actually not needed, but I did not know if I can safely do (b), and I have heard that threads cause problems with gtk.

So I tried to dig deeper for the hidden treasures of advanced haskell programming: I need a monad transformer! I expected the infamous `ContT` monad transformer to help, but I couldn’t figure out how, and I started to create my own monad transformer, called `CoroutineT`.

I tried to figure out what an action of type `(CoroutineT IO a)` should do, and I came up with this type signature:

pausingAction :: IO (Either (CoroutineT IO a) a)

which means that after the pausingAction is done, it is `Either` paused (and I get back another pausingAction to run when I want it), or it is done (and I get the result). Note that I’m writing `IO` here, but it can be any monad.

The definition of the datatype and the monad instance came mostly from trying to make this type work (yay to haskell’s type system, less thinking required), and looks like this:

data CoroutineT m a = CoroutineT {unCoroutineT :: (m (Either (CoroutineT m a) a)) }

instance (Monad m) => Monad (CoroutineT m) where

return v = CoroutineT (return (Right v))

a >>= b = CoroutineT $ do

r <- unCoroutineT a

case r of

Left paused -> return $ Left (paused >>= b)

Right unpaused -> unCoroutineT (b unpaused)

This translates to english like this: A call to return is not paused. When an action is already paused, further actions should be run after the paused action is resumed. When an action is not paused, further actions can happen now.

Like every well behaving monad transfomer, I also need a "`runCoroutineT`" function to start the coroutine. I probably could have used `unCoroutineT` directly, but for my use case (GUI drawing) I did not need a return value, so this function is more handy:

runCoroutineT :: Monad m => CoroutineT m () -> m (Maybe (CoroutineT m ()))

runCoroutineT a = either (Just) (const Nothing) `liftM` unCoroutineT a

Nothing surprising here, basically just turning the `Either` into a `Maybe`. So it becomes clear how to do (b): We can just throw away the resume action returned by `runCoroutineT` (if any). The more interesting thing is how we do (a): We need a pause action of type `(Coroutine m ())`. But how should it work? I did not really try to understand why it works, but by looking at the types, I came up with this:

pause :: Monad m => CoroutineT m ()

pause = CoroutineT (return (Left (CoroutineT (return (Right ())))))

Yes, it sounds like some dance step instructions (read the second line out aloud!), but it works somehow.

So here is some example code: I have a pausable `IO` action that counts from one to ten, pausing after each number. I also have function that resumes an pausable action up to *n* times:

example n = keepGoingFor n $ do
liftIO $ putStrLn "This is the coroutine"
forM_ [1..10] $ \i -> do
liftIO $ putStrLn $ "Counting to "++ show i ++" while you keep calling it"
pause
where --keepGoing :: Monad m => CoroutineT m () -> m ()
keepGoingFor 0 _ = putStrLn "Here I just abort the run"
keepGoingFor n cor = do
resume <- runCoroutineT cor
case resume of
Just runAgain -> keepGoingFor (n-1) runAgain
Nothing -> putStrLn "Finally stopped"

And here is the output of two different runs:

*CouroutineT> example 5

This is the coroutine

Counting to 1 while you keep calling it

Counting to 2 while you keep calling it

Counting to 3 while you keep calling it

Counting to 4 while you keep calling it

Counting to 5 while you keep calling it

Here I just abort the run

*CouroutineT> example 14

This is the coroutine

Counting to 1 while you keep calling it

Counting to 2 while you keep calling it

Counting to 3 while you keep calling it

Counting to 4 while you keep calling it

Counting to 5 while you keep calling it

Counting to 6 while you keep calling it

Counting to 7 while you keep calling it

Counting to 8 while you keep calling it

Counting to 9 while you keep calling it

Counting to 10 while you keep calling it

Finally stopped

So it does really works fine, and it proved very useful in my GUI drawing problem. For that, I created this nice control structure which works like `mapM_`, but calls pause every *n* iterations, and therefore hides the pausing stuff almost completely:

pausingForM_ :: Monad m => Int -> [a] -> (a -> CoroutineT m ()) -> CoroutineT m ()

pausingForM_ period list action = pausing' 0 list

where pausing' _ [] = return ()

pausing' n (x:xs) = do action x

if n==period then pause >> pausing' 0 xs

else pausing' (n+1) xs

I have put the complete module (including instances omitted here) in the darcs repository that might later also contain the fractal drawing program.

## Trackbacks