On Mon, 19 Mar 2001, Hannah Schroeter wrote:
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.
I see your point, and I must admit that this approach has its charm. It's not what I had in mind, though. Simon's MVars (in the Awkward Squad) come pretty close, but they're still not the sort of (cooperative) multitasking that I'm thinking of. I'm not looking for a process or thread model of concurrency. That's too expensive for simulations due to the frequency of task switches. (And thanks Rita, for the Eden reference. That's comparable to Concurrent Haskell.) The sort of lazy evaluation employed in your solution is in a way similar to coroutines, with the following restrictions (correct me if I'm wrong): * It is not possible to implement cyclic communication. * It is not possible to implement processes with multiple asynchronous output channels. I really would like to preserve the elegance of simulations in Simula, but with all the advantages Haskell offers. I believe that in current Haskell implementations all the components needed for "proper" coroutines are more or less there (because lazy evaluation is pretty close). Any more ideas? Thanks, --Andreas.