diff --git a/Fusion.hs b/Fusion.hs
--- a/Fusion.hs
+++ b/Fusion.hs
@@ -15,7 +15,7 @@
     , toListS, lazyToListS, runEffect, emptyStream
     , bracketS, next
     -- * StreamList
-    , ListT(..), concat
+    , ListT(..), concatL
     -- * Pipes
     , Producer, Pipe, Consumer
     , each, mapP
@@ -60,7 +60,7 @@
     fmap f (Stream k m) = Stream (fmap (fmap f) . k) m
     {-# INLINE fmap #-}
 
-instance Monad m => Applicative (Stream a m) where
+instance (Monad m, Applicative m) => Applicative (Stream a m) where
     pure x = Stream (pure . Done) (pure x)
     {-# INLINE pure #-}
     sf <*> sx = Stream (pure . Done) (runEffect sf <*> runEffect sx)
@@ -95,8 +95,8 @@
     go (Just (Stream ys j)) e@(Yield s _) = go' `liftM` (j >>= ys)
       where
         go' (Done _)    = Skip (Left s)
-        go' (Skip s')   = Skip (Right (e, Stream ys (pure s')))
-        go' (Yield s' a) = Yield (Right (e, Stream ys (pure s'))) a
+        go' (Skip s')   = Skip (Right (e, Stream ys (return s')))
+        go' (Yield s' a) = Yield (Right (e, Stream ys (return s'))) a
 {-# SPECIALIZE concatS :: Stream (Stream a IO r) IO r -> Stream a IO r #-}
 
 fromList :: Foldable f => Applicative m => f a -> Stream a m ()
@@ -107,7 +107,7 @@
 fromListM :: (Monad m, Foldable f) => m (f a) -> Stream a m ()
 fromListM xs = Stream (\case []     -> return $ Done ()
                              (y:ys) -> return $ Yield ys y)
-                      (toList <$> xs)
+                      (toList `liftM` xs)
 {-# INLINE fromListM #-}
 
 runEffect :: Monad m => Stream a m r -> m r
@@ -134,7 +134,7 @@
     go (Yield s a) = f s >>= liftM (a:) . unsafeInterleaveIO . go
 {-# INLINE lazyToListS #-}
 
-emptyStream :: Monad m => Stream Void m ()
+emptyStream :: (Monad m, Applicative m) => Stream Void m ()
 emptyStream = pure ()
 {-# INLINE emptyStream #-}
 
@@ -144,7 +144,7 @@
          -> (forall r. s -> (a -> s -> m r) -> (s -> m r) -> m r -> m r)
          -> Stream a m ()
 bracketS i f step = Stream go $ mask $ \_unmask -> do
-    s <- liftBase i
+    s   <- liftBase i
     key <- register (f s)
     return (s, key)
   where
@@ -152,6 +152,7 @@
         step s (\a s' -> return $ Yield (s', key) a)
                (\s'   -> return $ Skip (s', key))
                (release key >> (const (Done ()) `liftM` liftBase (f s)))
+{-
 {-# SPECIALIZE bracketS
       :: IO s
       -> (s -> IO ())
@@ -160,6 +161,7 @@
            -> SafeT IO r
            -> SafeT IO r)
       -> Stream a (SafeT IO) () #-}
+-}
 
 next :: Monad m => Stream a m r -> m (Either r (a, Stream a m r))
 next (Stream xs i) = do
@@ -179,20 +181,20 @@
     fmap f (ListT s) = ListT $ mapS f s
     {-# INLINE fmap #-}
 
-instance Monad m => Applicative (ListT m) where
+instance (Monad m, Applicative m) => Applicative (ListT m) where
     pure = return
     {-# INLINE pure #-}
     (<*>) = ap
     {-# INLINE (<*>) #-}
 
-instance Monad m => Monad (ListT m) where
+instance (Monad m, Applicative m) => Monad (ListT m) where
     return x = ListT $ fromList [x]
     {-# INLINE return #-}
     m >>= f = concatL $ fmap f m
     {-# INLINE (>>=) #-}
 
-concatL :: Monad m => ListT m (ListT m a) -> ListT m a
-concatL = ListT . concatS . getListT . fmap getListT
+concatL :: (Monad m, Applicative m) => ListT m (ListT m a) -> ListT m a
+concatL = ListT . concatS . getListT . liftM getListT
 {-# INLINE concatL #-}
 
 -- Pipes
@@ -201,10 +203,10 @@
 type Pipe     a b m r = Stream a m () -> Stream b m r
 type Consumer a   m r = Stream a m () -> m r
 
-each :: (Monad m, Foldable f) => f a -> Producer a m ()
+each :: (Applicative m, Foldable f) => f a -> Producer a m ()
 each = fromList
 {-# INLINE each #-}
 
-mapP :: Monad m => (a -> b) -> Pipe a b m ()
-mapP f = getListT . fmap f . ListT
+mapP :: (Monad m, Applicative m) => (a -> b) -> Pipe a b m ()
+mapP f = getListT . liftM f . ListT
 {-# INLINE mapP #-}
diff --git a/fusion.cabal b/fusion.cabal
--- a/fusion.cabal
+++ b/fusion.cabal
@@ -1,5 +1,5 @@
 name:                fusion
-version:             0.1.0
+version:             0.1.1
 synopsis:            Effectful streaming library based on shortcut fusion techniques
 description:         Effectful streaming library based on shortcut fusion techniques
 homepage:            https://github.com/jwiegley/fusion
@@ -16,9 +16,10 @@
   exposed-modules:     Fusion
   other-extensions:    DeriveFunctor, LambdaCase, RankNTypes, GADTs
   build-depends:       
-      base         >=4.8 && <4.9
-    , transformers >=0.4 && <0.5
+      base         >=4.7 && <5
+    , transformers >=0.3 && <0.5
     , pipes-safe   >=2.2 && <3
+    , void         >=0.7 && <1
   default-language:    Haskell2010
 
 Test-suite doctests