diff --git a/Control/Monad/Free.hs b/Control/Monad/Free.hs
--- a/Control/Monad/Free.hs
+++ b/Control/Monad/Free.hs
@@ -4,9 +4,11 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE DeriveGeneric, DeriveDataTypeable #-}
 {-# LANGUAGE FlexibleInstances, FlexibleContexts, UndecidableInstances #-}
+{-# OPTIONS -Wno-name-shadowing #-}
 
 module Control.Monad.Free (
    module Control.Monad,
+   module Control.Monad.Fail,
 -- * Free Monads
    MonadFree(..),
    Free(..), isPure, isImpure,
@@ -24,14 +26,16 @@
   ) where
 
 import Control.Applicative
-import Control.Monad
+import Control.Monad hiding (fail)
+import Control.Monad.Fail
 import Control.Monad.Trans.Class
 import Control.Monad.IO.Class
+import Data.Bifunctor
 import Data.Foldable
+import Data.Functor.Classes
 import Data.Traversable as T
 import Data.Typeable (Typeable)
 import GHC.Generics (Generic)
-import Prelude.Extras
 
 -- | This type class generalizes over encodings of Free Monads.
 class (Functor f, Monad m) => MonadFree f m where
@@ -44,26 +48,29 @@
 
 data Free f a = Impure (f (Free f a)) | Pure a deriving (Generic, Typeable)
 
-instance (Eq1 f) => Eq1 (Free f) where (==#) = (==)
-instance (Eq a, Eq1 f) => Eq (Free f a) where
- Pure a == Pure b = a == b
- Impure a == Impure b = a ==# b
- _ == _ = False
+instance (Eq1 f) => Eq1 (Free f) where
+ liftEq (==) (Pure a) (Pure b) = a == b
+ liftEq (==) (Impure a) (Impure b) = liftEq (liftEq (==)) a b
+ liftEq _ _ _ = False
+instance (Eq a, Eq1 f) => Eq (Free f a) where (==) = eq1
 
-instance Ord1 f => Ord1 (Free f) where compare1 = compare
+instance Ord1 f => Ord1 (Free f) where
+  liftCompare _ Impure{} Pure{} = LT
+  liftCompare _ Pure{} Impure{} = GT
+  liftCompare compare (Pure   a) (Pure   b) = compare a b
+  liftCompare compare (Impure a) (Impure b) = liftCompare (liftCompare compare) a b
 instance (Ord a, Ord1 f) => Ord (Free f a) where
-  compare Impure{} Pure{} = LT
-  compare Pure{} Impure{} = GT
-  compare (Pure   a) (Pure   b) = compare a b
-  compare (Impure a) (Impure b) = compare1 a b
+  compare = compare1
 
 instance (Show a, Show1 f) => Show (Free f a) where
   showsPrec p (Pure   a) = showParen (p > 0) $ ("Pure "   ++) . showsPrec  11 a
-  showsPrec p (Impure a) = showParen (p > 0) $ ("Impure " ++) . showsPrec1 11 a
+  showsPrec p (Impure a) = showParen (p > 0) $ ("Impure " ++) . liftShowsPrec showsPrec showList 11 a
 
 instance Functor f => Functor (Free f) where
-    fmap f (Pure a)    = Pure   (f a)
-    fmap f (Impure fa) = Impure (fmap (fmap f) fa)
+  fmap f = go where
+    go (Pure    a) = Pure (f a)
+    go (Impure fa) = Impure (fmap go fa)
+  {-# INLINE fmap #-}
 
 instance (Functor f, Foldable f) => Foldable (Free f) where
     foldMap f (Pure a)    = f a
@@ -84,6 +91,7 @@
   Impure f <*> x = Impure (fmap (<*> x) f)
 
 
+isPure, isImpure :: Free f a -> Bool
 isPure Pure{} = True; isPure _ = False
 isImpure = not . isPure
 
@@ -130,11 +138,8 @@
       f' (Left  x) = Left  <$> f x
       f' (Right x) = Right <$> (traverse.traverse) f x
 
-editEither l r = either (Left . l) (Right . r)
-conj f = FreeT . f . unFreeT
-
 instance (Functor f, Functor m) => Functor (FreeT f m) where
-    fmap f = conj $ fmap (editEither f ((fmap.fmap) f))
+    fmap f = FreeT . fmap (bimap f ((fmap.fmap) f)) . unFreeT
 
 instance (Functor f, Functor a, Monad a) => Applicative (FreeT f a) where
     pure = FreeT . return . Left
diff --git a/Control/Monad/Free/Improve.hs b/Control/Monad/Free/Improve.hs
--- a/Control/Monad/Free/Improve.hs
+++ b/Control/Monad/Free/Improve.hs
@@ -11,7 +11,6 @@
 {-# LANGUAGE Rank2Types #-}
 {-# LANGUAGE FlexibleContexts, FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverlappingInstances #-}
 
 module Control.Monad.Free.Improve (
    C(..), rep, improve
diff --git a/Control/Monad/Free/Zip.hs b/Control/Monad/Free/Zip.hs
--- a/Control/Monad/Free/Zip.hs
+++ b/Control/Monad/Free/Zip.hs
@@ -6,20 +6,29 @@
 import Control.Monad.Trans.State
 import Data.Foldable
 import Data.Traversable as T
+import Prelude hiding (fail)
 
-zipFree :: (Traversable f, Eq (f ()), Monad m) => (Free f a -> Free f b -> m (Free f c))
-                                                -> Free f a -> Free f b -> m (Free f c)
-zipFree f m1@(Impure a) m2@(Impure b)
-      | fmap (const ()) a == fmap (const ()) b = Impure `liftM` unsafeZipWithG f a b
+zipFree
+  :: (Traversable f, Eq (f ()), MonadFail m)
+  => (Free f a -> Free f b -> m (Free f c))
+  -> Free f a
+  -> Free f b
+  -> m (Free f c)
+zipFree f (Impure a) (Impure b)
+  | fmap (const ()) a == fmap (const ()) b = Impure `liftM` unsafeZipWithG f a b
 zipFree _ _ _ = fail "zipFree: structure mistmatch"
 
-zipFree_ :: (Traversable f, Eq (f ()), Monad m) => (Free f a -> Free f b -> m ()) -> Free f a -> Free f b -> m ()
-zipFree_ f m1@(Impure a) m2@(Impure b)
-      | fmap (const ()) a == fmap (const ()) b = zipWithM_ f (toList a) (toList b)
+zipFree_
+  :: (Traversable f, Eq (f ()), MonadFail m)
+  => (Free f a -> Free f b -> m ()) -> Free f a -> Free f b -> m ()
+zipFree_ f (Impure a) (Impure b)
+  | fmap (const ()) a == fmap (const ()) b = zipWithM_ f (toList a) (toList b)
 zipFree_ _ _ _ = fail "zipFree_: structure mismatch"
 
 
-unsafeZipWithG :: (Traversable t1, Traversable t2, Monad m) => (a -> b -> m c) ->  t1 a -> t2 b -> m(t2 c)
+unsafeZipWithG
+  :: (Traversable t1, Traversable t2, Monad m, MonadFail m)
+  => (a -> b -> m c) -> t1 a -> t2 b -> m (t2 c)
 unsafeZipWithG f t1 t2  = evalStateT (T.mapM zipG' t2) (toList t1)
        where zipG' y = do (x:xx) <- get
                           put xx
diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain
diff --git a/control-monad-free.cabal b/control-monad-free.cabal
--- a/control-monad-free.cabal
+++ b/control-monad-free.cabal
@@ -1,6 +1,6 @@
 name: control-monad-free
-version: 0.6.1
-Cabal-Version:  >= 1.6
+version: 0.6.2
+Cabal-Version:  >= 1.24
 build-type: Simple
 license: PublicDomain
 author: Luke Palmer, Pepe Iborra
@@ -16,8 +16,7 @@
  
 synopsis: Free monads and monad transformers
 category: Control, Monads
-stability: experimental
-tested-with: GHC >= 6.8
+stability: stable
 
 source-repository head
   type:     git
@@ -25,8 +24,9 @@
 
 Library
   buildable: True
-  build-depends: base >= 2 && < 5, transformers, prelude-extras
-  extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances, OverlappingInstances
+  build-depends: base >= 4.9 && < 5, transformers
+  default-language: Haskell2010
+  default-extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances
   exposed-modules:
      Control.Monad.Free
      Control.Monad.Free.Zip