diff --git a/Control/Monad/Free.hs b/Control/Monad/Free.hs
--- a/Control/Monad/Free.hs
+++ b/Control/Monad/Free.hs
@@ -7,9 +7,9 @@
    module Control.Monad,
 -- * Free Monads
    MonadFree(..),
-   Free(..),
+   Free(..), isPure, isImpure,
    foldFree, foldFreeM,
-   evalFree, mapFree,
+   evalFree, mapFree, mapFreeM,
 -- * Free Monad Transformers
    FreeT(..),
    foldFreeT, foldFreeT', mapFreeT,
@@ -56,6 +56,9 @@
     Pure a    >>= f = f a
     Impure fa >>= f = Impure (fmap (>>= f) fa)
 
+isPure Pure{} = True; isPure _ = False
+isImpure = not . isPure
+
 foldFree :: Functor f => (a -> b) -> (f b -> b) -> Free f a -> b
 foldFree pure _    (Pure   x) = pure x
 foldFree pure imp  (Impure x) = imp (fmap (foldFree pure imp) x)
@@ -69,9 +72,11 @@
 evalFree _ i (Impure x) = i x
 
 mapFree :: (Functor f, Functor g) => (forall a. f a -> g a) -> Free f a -> Free g a
-mapFree eta (Pure a)   = Pure a
-mapFree eta (Impure x) = Impure (fmap (mapFree eta) (eta x))
+mapFree eta = foldFree Pure (Impure . eta)
 
+mapFreeM :: (Traversable f, Functor g, Monad m) => (forall a. f a -> m(g a)) -> Free f a -> m(Free g a)
+mapFreeM eta = foldFreeM (return . Pure) (liftM Impure . eta)
+
 -- * Monad Transformer
 --   (built upon Luke Palmer control-monad-free hackage package)
 newtype FreeT f m a = FreeT { unFreeT :: m (Either a (f (FreeT f m a))) }
@@ -94,6 +99,10 @@
         case r of
              Left  x  -> unFreeT $ f x
              Right xc -> return . Right $ fmap (>>= f) xc
+
+instance (Functor f, Monad m) => MonadFree f (FreeT f m) where
+    wrap = FreeT . return . Right
+    free = lift . unFreeT
 
 instance (Functor f) => MonadTrans (FreeT f) where
     lift = FreeT . liftM 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,6 +11,7 @@
 {-# 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
@@ -1,21 +1,26 @@
+{-# LANGUAGE CPP #-}
 module Control.Monad.Free.Zip (zipFree, zipFree_) where
 
 import Control.Monad.Free
+import Control.Monad.Trans
+#ifdef TRANSFORMERS
+import Control.Monad.Trans.State
+#else
 import Control.Monad.State
+#endif
 import Data.Foldable
 import Data.Traversable as T
 
-zipFree :: (Traversable f, Eq (f ()), Monad m) => (a -> b -> m c) -> Free f a -> Free f b -> m (Free f c)
-zipFree f (Pure a) (Pure b) = Pure `liftM` f a b
+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 (zipFree f) a b
-zipFree _ _ _ = fail "zipFree: not the same structure"
+      | fmap (const ()) a == fmap (const ()) b = Impure `liftM` unsafeZipWithG f a b
+zipFree _ _ _ = fail "zipFree: structure mistmatch"
 
-zipFree_ :: (Traversable f, Eq (f ()), Monad m) => (a -> b -> m ()) -> Free f a -> Free f b -> m ()
-zipFree_ f (Pure a) (Pure b) = f a b
+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_ (zipFree_ f) (toList a) (toList b)
-zipFree_ _ _ _ = fail "zipFree: not the same structure"
+      | 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)
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/Setup.lhs b/Setup.lhs
deleted file mode 100644
--- a/Setup.lhs
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/usr/bin/env runhaskell
-> 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,5 +1,5 @@
 name: control-monad-free
-version: 0.4
+version: 0.5
 Cabal-Version:  >= 1.2.3
 build-type: Simple
 license: PublicDomain
@@ -18,11 +18,18 @@
 category: Control, Monads
 stability: experimental
 
+Flag transformers
+   default: True
 
 Library
   buildable: True
-  build-depends: base, mtl
-  extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances
+  build-depends: base >= 2 && < 5
+  if flag(transformers)
+     build-depends: transformers
+     cpp-options: -DTRANSFORMERS
+  else
+     build-depends: mtl
+  extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances, OverlappingInstances
   exposed-modules:
      Control.Monad.Free
      Control.Monad.Free.Zip