diff --git a/Control/Monad/Coroutine/SuspensionFunctors.hs b/Control/Monad/Coroutine/SuspensionFunctors.hs
--- a/Control/Monad/Coroutine/SuspensionFunctors.hs
+++ b/Control/Monad/Coroutine/SuspensionFunctors.hs
@@ -60,8 +60,8 @@
 instance Functor (Request x f) where
    fmap f (Request x g) = Request x (f . g)
 
-data ParseRequest x z = forall y. MonoidNull y => 
-                        ParseRequest ([x] -> [x]) (Parser [x] y) ((y, Maybe (Parser [x] y)) -> z)
+data ParseRequest x z = forall a y. MonoidNull y => 
+                        ParseRequest ([x] -> [x]) (Parser a [x] y) ((y, Maybe (Parser a [x] y)) -> z)
 instance Functor (ParseRequest x) where
    fmap f (ParseRequest b p g) = ParseRequest b p (f . g)
 
@@ -89,7 +89,7 @@
 request x = suspend (Request x return)
 
 -- | Suspend yielding a request and awaiting the response.
-requestParse :: (Monad m, MonoidNull y) => Parser [x] y -> Coroutine (ParseRequest x) m (y, Maybe (Parser [x] y))
+requestParse :: (Monad m, MonoidNull y) => Parser a [x] y -> Coroutine (ParseRequest x) m (y, Maybe (Parser a [x] y))
 requestParse p = suspend (ParseRequest id p return)
 
 -- | Converts a coroutine yielding collections of values into one yielding single values.
@@ -214,15 +214,15 @@
 -- | Like 'parserYieldResolver', the only difference being that the producing coroutine sends its chunks using 'request'
 -- rather than 'yield'. The feedback received from 'request' is the unconsumed remainder of the chunk, which lets the
 -- coroutine know when its sibling terminates.
-parserRequestResolver :: Monoid y => SeesawResolver (Request (Parser [x] y) y) (Request [x] [x])
-                                                    (Request (Parser [x] y) y) (Request [x] [x])
+parserRequestResolver :: Monoid y => SeesawResolver (Request (Parser a [x] y) y) (Request [x] [x])
+                                                    (Request (Parser a [x] y) y) (Request [x] [x])
 parserRequestResolver = liftedParserRequestResolver id id
 
 -- | A generic version of 'parserRequestResolver', allowing coroutines with 'Request' functors embedded in other
 -- functors.
 liftedParserRequestResolver :: (Functor s1, Functor s2, Monoid y) =>
-                               (forall a. Request (Parser [x] y) y a -> s1 a) -> (forall a. Request [x] [x] a -> s2 a)
-                               -> SeesawResolver (Request (Parser [x] y) y) (Request [x] [x]) s1 s2
+                               (forall b. Request (Parser a [x] y) y b -> s1 b) -> (forall b. Request [x] [x] b -> s2 b)
+                               -> SeesawResolver (Request (Parser a [x] y) y) (Request [x] [x]) s1 s2
 liftedParserRequestResolver lift1 lift2 = SeesawResolver {
    resumeLeft= \(Request _ c)-> c mempty,
    resumeRight= \(Request chunk c)-> c chunk,
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.7
+Version:             0.7.1
 Cabal-Version:       >= 1.2
 Build-Type:          Simple
 Synopsis:            Coroutine monad transformer for suspending and resuming monadic computations