Changes between Version 1 and Version 2 of Architecture

Timestamp:

01/14/10 00:46:24 (3 years ago)

Author:

blamario (IP: 99.241.117.248)

Comment:

Renamed Trampoline to Coroutine to match the API

Architecture

@@ -5 +5 @@
 == The lowest layer: trampoline-style nestable coroutines ==
 
-This layer, implemented by the Control.Concurrent.Trampoline module, provides a limited coroutine functionality in Haskell. The centerpiece of the approach is the monad transformer Trampoline, that transforms an arbitrary monadic computation into a suspendable and resumable one. The basic definition is simple:
+This layer, implemented by the Control.Concurrent.Coroutine module, provides a limited coroutine functionality in Haskell. The centerpiece of the approach is the monad transformer Coroutine, that transforms an arbitrary monadic computation into a suspendable and resumable one. The basic definition is simple:
 
 {{{
-newtype Trampoline s m r = Trampoline {bounce :: m (TrampolineState s m r)}
+newtype Coroutine s m r = Coroutine {resume :: m (CoroutineState s m r)}
 
-data TrampolineState s m r = Done r | Suspend! (s (Trampoline s m r))
+data CoroutineState s m r = Done r | Suspend! (s (Coroutine s m r))
 
-instance (Functor s, Monad m) => Monad (Trampoline s m) where
-   return x = Trampoline (return (Done x))
-   t >>= f = Trampoline (bounce t >>= apply f)
-      where apply f (Done x) = bounce (f x)
+instance (Functor s, Monad m) => Monad (Coroutine s m) where
+   return x = Coroutine (return (Done x))
+   t >>= f = Coroutine (resume t >>= apply f)
+      where apply f (Done x) = resume (f x)
             apply f (Suspend s) = return (Suspend (fmap (>>= f) s))
 }}}
 
-The Trampoline transformer type is parameterized by a functor. Here is an example of one functor particularly useful for a Trampoline computation:
+The Coroutine transformer type is parameterized by a functor. Here is an example of one functor particularly useful for a Coroutine computation:
 
 {{{
@@ -29 +29 @@
 == Streams ==
 
-The next layer builds on the trampoline foundation to provide streaming computations. The main idea here is to introduce sinks and sources:
+The next layer builds on the coroutine foundation to provide streaming computations. The main idea here is to introduce sinks and sources:
 
 {{{
 data Sink (m :: * -> *) a x = Sink {
-   put :: forall d. (AncestorFunctor a d) => x -> Trampoline d m Bool,
-   canPut :: forall d. (AncestorFunctor a d) => Trampoline d m Bool
+   put :: forall d. (AncestorFunctor a d) => x -> Coroutine d m Bool,
+   canPut :: forall d. (AncestorFunctor a d) => Coroutine d m Bool
    }
 
 newtype Source (m :: * -> *) a x = Source {
-   get :: forall d. (AncestorFunctor a d) => Trampoline d m (Maybe x)
+   get :: forall d. (AncestorFunctor a d) => Coroutine d m (Maybe x)
    }
 }}}
@@ -46 +46 @@
 {{{
 pipe :: forall m a a1 a2 x r1 r2. (Monad m, Functor a, a1 ~ SinkFunctor a x, a2 ~ SourceFunctor a x) =>
-        (Sink m a1 x -> Trampoline a1 m r1) -> (Source m a2 x -> Trampoline a2 m r2) -> Trampoline a m (r1, r2)
+        (Sink m a1 x -> Coroutine a1 m r1) -> (Source m a2 x -> Coroutine a2 m r2) -> Coroutine a m (r1, r2)
 }}}
 
@@ -56 +56 @@
 
 {{{
-type OpenConsumer m a d x r = AncestorFunctor a d => Source m a x -> Trampoline d m r
-type OpenProducer m a d x r = AncestorFunctor a d => Sink m a x -> Trampoline d m r
+type OpenConsumer m a d x r = AncestorFunctor a d => Source m a x -> Coroutine d m r
+type OpenProducer m a d x r = AncestorFunctor a d => Sink m a x -> Coroutine d m r
 type OpenTransducer m a1 a2 d x y = 
-   (AncestorFunctor a1 d, AncestorFunctor a2 d) => Source m a1 x -> Sink m a2 y -> Trampoline d m [x]
+   (AncestorFunctor a1 d, AncestorFunctor a2 d) => Source m a1 x -> Sink m a2 y -> Coroutine d m [x]
 type OpenSplitter m a1 a2 a3 a4 d x b =
    (AncestorFunctor a1 d, AncestorFunctor a2 d, AncestorFunctor a3 d, AncestorFunctor a4 d) =>
-   Source m a1 x -> Sink m a2 x -> Sink m a3 x -> Sink m a4 b -> Trampoline d m [x]
+   Source m a1 x -> Sink m a2 x -> Sink m a3 x -> Sink m a4 b -> Coroutine d m [x]
 
 newtype Consumer m x r = Consumer {consume :: forall a d. OpenConsumer m a d x r}