diff --git a/Control/Monad/Coroutine.hs b/Control/Monad/Coroutine.hs
--- a/Control/Monad/Coroutine.hs
+++ b/Control/Monad/Coroutine.hs
@@ -62,16 +62,17 @@
     mapMonad, mapSuspension, 
     -- * Running Coroutine computations
     Naught, runCoroutine, pogoStick, foldRun, seesaw, SeesawResolver(..),
-    -- * Nested and coupled Coroutine computations
-    NestedFunctor (NestedFunctor), SomeFunctor(..), nest,
+    -- * Coupled Coroutine computations
+    SomeFunctor(..), composePair,
     couple, merge
    )
 where
 
 import Control.Monad (liftM, when)
-import Control.Monad.Trans (MonadTrans(..), MonadIO(..))
+import Control.Monad.IO.Class (MonadIO(..))
+import Control.Monad.Trans.Class (MonadTrans(..))
 import Data.Either (either, partitionEithers)
-import Data.Traversable (Traversable, sequence)
+import Data.Functor.Compose (Compose(..))
 
 import Control.Monad.Parallel
 
@@ -110,21 +111,16 @@
 instance Functor Naught where
    fmap f _ = undefined
 
--- | Combines two functors into one, applying both.
-newtype NestedFunctor l r x = NestedFunctor (l (r x))
-instance (Functor l, Functor r) => Functor (NestedFunctor l r) where
-   fmap f (NestedFunctor lr) = NestedFunctor ((fmap . fmap) f lr)
-
 -- | Combines two functors into one, applying either or both of them. Used for coupled coroutines.
-data SomeFunctor l r x = LeftSome (l x) | RightSome (r x) | Both (NestedFunctor l r x)
+data SomeFunctor l r x = LeftSome (l x) | RightSome (r x) | Both (Compose l r x)
 instance (Functor l, Functor r) => Functor (SomeFunctor l r) where
    fmap f (LeftSome l) = LeftSome (fmap f l)
    fmap f (RightSome r) = RightSome (fmap f r)
    fmap f (Both lr) = Both (fmap f lr)
 
--- | Combines two values under two functors into a pair of values under a single 'NestedFunctor'.
-nest :: (Functor a, Functor b) => a x -> b y -> NestedFunctor a b (x, y)
-nest a b = NestedFunctor $ fmap (\x-> fmap ((,) x) b) a
+-- | Combines two values under two functors into a pair of values under a single 'Compose'.
+composePair :: (Functor a, Functor b) => a x -> b y -> Compose a b (x, y)
+composePair a b = Compose $ fmap (\x-> fmap ((,) x) b) a
 
 -- | Suspend the current 'Coroutine'.
 suspend :: (Monad m, Functor s) => s (Coroutine s m x) -> Coroutine s m x
@@ -169,7 +165,7 @@
 couple runPair t1 t2 = Coroutine{resume= runPair proceed (resume t1) (resume t2)} where
    proceed :: CoroutineStepResult s1 m x -> CoroutineStepResult s2 m y -> m (CoroutineStepResult (SomeFunctor s1 s2) m (x, y))
    proceed (Right x) (Right y) = return $ Right (x, y)
-   proceed (Left s1) (Left s2) = return $ Left $ fmap (uncurry (couple runPair)) (Both $ nest s1 s2)
+   proceed (Left s1) (Left s2) = return $ Left $ fmap (uncurry (couple runPair)) (Both $ composePair s1 s2)
    proceed (Right x) (Left s2) = return $ Left $ fmap (couple runPair (return x)) (RightSome s2)
    proceed (Left s1) (Right y) = return $ Left $ fmap (flip (couple runPair) (return y)) (LeftSome s1)
 
diff --git a/Control/Monad/Coroutine/Nested.hs b/Control/Monad/Coroutine/Nested.hs
--- a/Control/Monad/Coroutine/Nested.hs
+++ b/Control/Monad/Coroutine/Nested.hs
@@ -39,7 +39,7 @@
 where
 
 import Control.Monad (join, liftM)
-import Control.Monad.Trans (lift)
+import Control.Monad.Trans.Class (lift)
 
 import Control.Monad.Coroutine
 import Control.Monad.Coroutine.SuspensionFunctors
@@ -66,7 +66,7 @@
    proceed (Left (RightF s)) (Right y) = Left $ RightF $ fmap (flip coupleNested' (return y)) (LeftSome s)
    proceed (Right x) (Left (RightF s)) = Left $ RightF $ fmap (coupleNested' (return x)) (RightSome s)
    proceed (Left (RightF s1)) (Left (RightF s2)) =
-      Left $ RightF $ fmap (uncurry coupleNested') (Both $ nest s1 s2)
+      Left $ RightF $ fmap (uncurry coupleNested') (Both $ composePair s1 s2)
    proceed l (Left (LeftF s)) = Left $ LeftF $ fmap (coupleNested' (Coroutine $ return l)) s
    proceed (Left (LeftF s)) r = Left $ LeftF $ fmap (flip coupleNested' (Coroutine $ return r)) s
 
diff --git a/TestCoroutine.hs b/TestCoroutine.hs
--- a/TestCoroutine.hs
+++ b/TestCoroutine.hs
@@ -21,8 +21,9 @@
 import Prelude hiding (sequence)
 import Control.Exception (assert)
 import Control.Monad (liftM, mapM, when)
-import Control.Monad.Identity (runIdentity)
 import Control.Parallel (pseq)
+import Data.Functor.Compose (Compose(..))
+import Data.Functor.Identity (runIdentity)
 import Data.List (find)
 import Data.Maybe (fromJust)
 import System.Environment (getArgs)
@@ -58,7 +59,7 @@
                   resume
                   (couple bindM2 (fibs 1) (fibs 2))
    where resume :: SomeFunctor (Yield Integer) (Yield Integer) c -> c
-         resume (Both (NestedFunctor (Yield n1 (Yield n2 c)))) = assert (n1 == n2) c
+         resume (Both (Compose (Yield n1 (Yield n2 c)))) = assert (n1 == n2) c
          fibs ix = mapM_ (yieldApply (fib ix)) nums >> return (fib ix $ last nums)
 
 twoFibsSeesaw :: MonadParallel m => [Int] -> m Integer
diff --git a/monad-coroutine.cabal b/monad-coroutine.cabal
--- a/monad-coroutine.cabal
+++ b/monad-coroutine.cabal
@@ -1,5 +1,5 @@
 Name:                monad-coroutine
-Version:             0.5
+Version:             0.5.1
 Cabal-Version:       >= 1.2
 Build-Type:          Simple
 Synopsis:            Coroutine monad transformer for suspending and resuming monadic computations
@@ -23,5 +23,5 @@
 
 Library
   Exposed-Modules:   Control.Monad.Coroutine, Control.Monad.Coroutine.SuspensionFunctors, Control.Monad.Coroutine.Nested
-  Build-Depends:     base < 5, monad-parallel, transformers
+  Build-Depends:     base < 5, monad-parallel, transformers >= 0.2 && < 0.3
   GHC-prof-options:  -auto-all