Coroutines

[Hannah Schroeter]

Hello!

On Mon, Mar 19, 2001 at 06:43:55PM +0100, Andreas Gruenbacher wrote:
> On Mon, 19 Mar 2001, Simon Peyton-Jones wrote:

> > Lazy evaluation *is* coroutines, in a way.

> What I had in mind was something like the following (pseudocode), which
> could easily be implemented on top of coroutines:

> class Channel c t where
> 	send    :: t -> c -> IO ()
> 	receive ::      c -> IO t

> sender :: Int -> Channel -> ...
> sender n receiver = do send n receiver
>                        return (sender (n+1) receiver)

> receiver :: Channel -> ...
> receiver sender = do i <- receive sender
>                      return (receiver sender)

> c :: Channel Int
> c = ...

> main = run_them [ sender 1 c, receiver c ]

Now, you can do this:

sender :: Int -> [Int]
sender n = n:(sender (n+1))

receiver :: [Int] -> ()
receiver (x:xs) = receiver xs

main =
	let
		sent_stuff = sender 1
		receiver_result = receiver sent_stuff
	in
		receiver_result `seq` return ()

I.e. lazy lists work like coroutine channels often enough.

You can do that a bit more abstractly:

send :: a -> [a] -> [a]
send = (:)

receive :: (a -> [a] -> result) -> [a] -> result
receive f (x:xs) = f x xs

sender n = send n $ sender (n+1)
receiver = receive $ \received_thing -> receiver

main = (as above)

Note that the definition of sender now looks not too unsimilar to
your monadic things:

sender n = send n >> sender (n+1)
 ===
sender n = do
	send n
	sender (n+1) -- your 'return' above is redundant

receiver = receive >>= \received_thing -> receiver
 ===
receiver = do
	received_thing <- receive
	receiver

Now, in fact, you could achieve this effect with a continuation+state monad
quite well (state for input, continuation as *one* way for lazy output).

> [...]

Kind regards,

Hannah.