diff --git a/Data/Compressed/Internal/LZ78.hs b/Data/Compressed/Internal/LZ78.hs
--- a/Data/Compressed/Internal/LZ78.hs
+++ b/Data/Compressed/Internal/LZ78.hs
@@ -44,10 +44,12 @@
 import qualified Data.HashMap.Lazy as HashMap
 import qualified Data.List as List
 import Data.Generator
-import Data.Foldable
 import Data.Function (on)
 import Data.Functor
 import Data.Key as Key
+import Data.Foldable
+import Data.Traversable
+import Data.Semigroup
 import Data.Pointed
 import Text.Read
 import Control.Comonad
@@ -192,22 +194,20 @@
 
 instance Applicative LZ78 where
   pure a = Cons (Token 0 a) Nil
-  fs <*> as = extract <$> encode 
-    [ Entry (i,j) (f a) 
-    | Entry i f <- decode (entries fs)
-    , Entry j a <- decode (entries as) 
-    ]
+  fs <*> as = fmap extract $ encode $ do
+    Entry i f <- decode (entries fs)
+    Entry j a <- decode (entries as) 
+    return $ Entry (i,j) (f a)
   as *> bs = fmap extract $ encode $ Prelude.concat $ replicate (reduceWith getCount as)  $  decode (entries bs)
   as <* bs = fmap extract $ encode $ Prelude.concat $ replicate (reduceWith getCount bs) <$> decode (entries as)
 
 instance Monad LZ78 where
   return a = Cons (Token 0 a) Nil
   (>>) = (*>)
-  as >>= k = extract <$> encode 
-    [ Entry (i,j) b 
-    | Entry i a <- decode (entries as)
-    , Entry j b <- decode (entries (k a))
-    ]
+  as >>= k = fmap extract $ encode $ do
+    Entry i a <- decode (entries as)
+    Entry j b <- decode (entries (k a))
+    return $ Entry (i,j) b 
 
 instance Adjustable LZ78 where
   adjust f i = fmap extract . encode . adjust (Entry (-1) . f . extract) i . decode . entries
diff --git a/Data/Compressed/RunLengthEncoding.hs b/Data/Compressed/RunLengthEncoding.hs
--- a/Data/Compressed/RunLengthEncoding.hs
+++ b/Data/Compressed/RunLengthEncoding.hs
@@ -147,11 +147,10 @@
 
 instance Applicative RLE where
   pure = RLE . F.singleton . pure
-  RLE fs <*> RLE as = RLE $ F.fromList 
-    [ Run (n * m) (f a)
-    | Run n f <- toList fs
-    , Run m a <- toList as
-    ]
+  RLE fs <*> RLE as = RLE $ F.fromList $ do
+    Run n f <- toList fs
+    Run m a <- toList as
+    return $ Run (n * m) (f a)
   RLE as <* RLE bs = RLE $ F.fmap' (\(Run n a) -> Run (n * m) a) as where
     m = reduceWith getCount bs
   RLE as *> RLE bs = RLE $ mconcat $ replicate (reduceWith getCount as) bs
diff --git a/compressed.cabal b/compressed.cabal
--- a/compressed.cabal
+++ b/compressed.cabal
@@ -1,6 +1,6 @@
 name:          compressed
 category:      Data, Compression, MapReduce
-version:       0.1.1
+version:       0.1.2
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -29,8 +29,8 @@
     semigroupoids          >= 1.2.2.4  && < 1.3,
     comonad                >= 1.1.1    && < 1.2,
     pointed                >= 2.0      && < 2.1,
-    keys                   >= 2.0      && < 2.1,
-    reducers               >= 0.1      && < 0.2
+    keys                   >= 2.1      && < 2.2,
+    reducers               >= 0.1.4    && < 0.2
 
   exposed-modules:
     Data.Compressed.LZ78