Changes between Version 4 and Version 5 of Architecture

Timestamp:

03/06/10 22:17:18 (3 years ago)

Author:

blamario (IP: 99.241.117.248)

Comment:

--

Architecture

@@ -5 +5 @@
 == Infrastructure ==
 
-The framework relies on the [wiki:monad-parallel monad-parallel] package to enable parallel execution of multiple coroutines' steps.
-
-== The lowest layer: trampoline-style nestable coroutines ==
-
-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 Coroutine s m r = Coroutine {resume :: m (CoroutineState s m r)}
-
-data CoroutineState s m r = Done r | Suspend! (s (Coroutine s m r))
-
-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 Coroutine transformer type is parameterized by a functor. Here is an example of one functor particularly useful for a Coroutine computation:
-
-{{{
-data Yield x y = Yield x y
-instance Functor (Yield x) where
-   fmap f (Yield x y) = Yield x (f y)
-}}}
+The framework relies on the following packages:
+ * [wiki:monad-parallel monad-parallel] to enable parallel execution of monadic computations, and
+ * [wiki:monad-coroutine monad-coroutine] to enable the same monadic computations to suspend and resume each other.
 
 == Streams ==
 
-The next layer builds on the coroutine foundation to provide streaming computations. The main idea here is to introduce sinks and sources:
+The lowest layer builds on the coroutine foundation to provide streaming computations. The main idea here is to introduce sinks and sources:
 
 {{{