diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,9 @@
+4.12.2
+------
+* Add instances for `ExceptT`: like `ErrorT`, but without an `Error` constraint.
+* Support `containers`
+* Support `transformers` 0.5
+
 4.12.1
 ------
 * Support GHC 7.4
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -1,7 +1,7 @@
 free
 ====
 
-[![Build Status](https://secure.travis-ci.org/ekmett/free.png?branch=master)](http://travis-ci.org/ekmett/free)
+[![Hackage](https://img.shields.io/hackage/v/free.svg)](https://hackage.haskell.org/package/free) [![Build Status](https://secure.travis-ci.org/ekmett/free.png?branch=master)](http://travis-ci.org/ekmett/free)
 
 This package provides a common definitions for working with free monads, free applicatives, and cofree comonads in Haskell.
 
diff --git a/examples/Cabbage.lhs b/examples/Cabbage.lhs
--- a/examples/Cabbage.lhs
+++ b/examples/Cabbage.lhs
@@ -43,7 +43,7 @@
 
 @
 *Cabbage> singleOut1 (== Sheep) [Wolf, Sheep, Cabbage]
-[(Just Wolf,[Sheep,Cabbage]),(Just Sheep,[Wolf,Cabbage]),(Just Cabbage,[Wolf,Sheep]),(Nothing,[Wolf,Sheep,Cabbage])]
+(Just Sheep,[Wolf,Cabbage])
 @
 
 > singleOutAll :: [a] -> [(Maybe a,[a])]
diff --git a/free.cabal b/free.cabal
--- a/free.cabal
+++ b/free.cabal
@@ -1,6 +1,6 @@
 name:          free
 category:      Control, Monads
-version:       4.12.1
+version:       4.12.2
 license:       BSD3
 cabal-version: >= 1.10
 license-file:  LICENSE
@@ -76,9 +76,11 @@
     profunctors          >= 4 && < 6,
     semigroupoids        >= 4 && < 6,
     semigroups           >= 0.8.3.1 && < 1,
-    transformers         >= 0.2.0   && < 0.5,
+    transformers         >= 0.2.0   && < 0.6,
+    transformers-compat  >= 0.3     && < 1,
     template-haskell     >= 2.7.0.0 && < 3,
-    exceptions           >= 0.6 && < 0.9
+    exceptions           >= 0.6 && < 0.9,
+    containers           < 0.6
 
   exposed-modules:
     Control.Applicative.Free
diff --git a/src/Control/Comonad/Cofree.hs b/src/Control/Comonad/Cofree.hs
--- a/src/Control/Comonad/Cofree.hs
+++ b/src/Control/Comonad/Cofree.hs
@@ -25,6 +25,7 @@
   , ComonadCofree(..)
   , section
   , coiter
+  , coiterW
   , unfold
   , unfoldM
   , hoistCofree
@@ -41,6 +42,7 @@
 import Control.Comonad.Env.Class
 import Control.Comonad.Store.Class as Class
 import Control.Comonad.Traced.Class
+import Control.Comonad.Hoist.Class
 import Control.Category
 import Control.Monad(ap, (>=>), liftM)
 import Control.Monad.Zip
@@ -64,7 +66,7 @@
 -- /Formally/
 --
 -- A 'Comonad' @v@ is a cofree 'Comonad' for @f@ if every comonad homomorphism
--- another comonad @w@ to @v@ is equivalent to a natural transformation
+-- from another comonad @w@ to @v@ is equivalent to a natural transformation
 -- from @w@ to @f@.
 --
 -- A 'cofree' functor is right adjoint to a forgetful functor.
@@ -110,6 +112,10 @@
 coiter :: Functor f => (a -> f a) -> a -> Cofree f a
 coiter psi a = a :< (coiter psi <$> psi a)
 
+-- | Like coiter for comonadic values.
+coiterW :: (Comonad w, Functor f) => (w a -> f (w a)) -> w a -> Cofree f a
+coiterW psi a = extract a :< (coiterW psi <$> psi a)
+
 -- | Unfold a cofree comonad from a seed.
 unfold :: Functor f => (b -> (a, f b)) -> b -> Cofree f a
 unfold f c = case f c of
@@ -151,7 +157,7 @@
   {-# INLINE lower #-}
 
 instance Alternative f => Monad (Cofree f) where
-  return x = x :< empty
+  return = pure
   {-# INLINE return #-}
   (a :< m) >>= k = case k a of
                      b :< n -> b :< (n <|> fmap (>>= k) m)
@@ -182,7 +188,7 @@
   {-# INLINE (@>) #-}
 
 instance Alternative f => Applicative (Cofree f) where
-  pure = return
+  pure x = x :< empty
   {-# INLINE pure #-}
   (<*>) = ap
   {-# INLINE (<*>) #-}
@@ -235,6 +241,10 @@
   foldMap f = go where
     go (a :< as) = f a `mappend` foldMap go as
   {-# INLINE foldMap #-}
+#if __GLASGOW_HASKELL__ >= 709
+  length = go 0 where
+    go s (_ :< as) = foldl' go (s + 1) as
+#endif
 
 instance Foldable1 f => Foldable1 (Cofree f) where
   foldMap1 f = go where
@@ -291,6 +301,9 @@
 {-# NOINLINE cofreeDataType #-}
 #endif
 
+instance ComonadHoist Cofree where
+  cohoist = hoistCofree
+
 instance ComonadEnv e w => ComonadEnv e (Cofree w) where
   ask = ask . lower
   {-# INLINE ask #-}
@@ -331,12 +344,24 @@
 _unwrap  f (a :< as) = (a :<) <$> f as
 {-# INLINE _unwrap #-}
 
--- | Construct a @Lens@ into a @'Cofree' f@ given a list of lenses into the base functor.
+-- | Construct an @Lens@ into a @'Cofree' g@ given a list of lenses into the base functor.
+-- When the input list is empty, this is equivalent to '_extract'.
+-- When the input list is non-empty, this composes the input lenses
+-- with '_unwrap' to walk through the @'Cofree' g@ before using
+-- '_extract' to get the element at the final location.
 --
 -- For more on lenses see the 'lens' package on hackage.
 --
--- @telescoped :: 'Functor' g => [Lens' ('Cofree' g a) (g ('Cofree' g a))] -> Lens' ('Cofree' g a) a@
-telescoped :: (Functor f, Functor g) =>
+-- @telescoped :: [Lens' (g ('Cofree' g a)) ('Cofree' g a)]      -> Lens' ('Cofree' g a) a@
+--
+-- @telescoped :: [Traversal' (g ('Cofree' g a)) ('Cofree' g a)] -> Traversal' ('Cofree' g a) a@
+--
+-- @telescoped :: [Getter (g ('Cofree' g a)) ('Cofree' g a)]     -> Getter ('Cofree' g a) a@
+--
+-- @telescoped :: [Fold (g ('Cofree' g a)) ('Cofree' g a)]       -> Fold ('Cofree' g a) a@
+--
+-- @telescoped :: [Setter' (g ('Cofree' g a)) ('Cofree' g a)]    -> Setter' ('Cofree' g a) a@
+telescoped :: Functor f =>
              [(Cofree g a -> f (Cofree g a)) -> g (Cofree g a) -> f (g (Cofree g a))] ->
               (a -> f a) -> Cofree g a -> f (Cofree g a)
 telescoped = Prelude.foldr (\l r -> _unwrap . l . r) _extract
diff --git a/src/Control/Comonad/Cofree/Class.hs b/src/Control/Comonad/Cofree/Class.hs
--- a/src/Control/Comonad/Cofree/Class.hs
+++ b/src/Control/Comonad/Cofree/Class.hs
@@ -23,6 +23,7 @@
 import Control.Comonad.Trans.Traced
 import Control.Comonad.Trans.Identity
 import Data.List.NonEmpty
+import Data.Tree
 import Data.Semigroup
 
 -- | Allows you to peel a layer off a cofree comonad.
@@ -33,6 +34,9 @@
 instance ComonadCofree Maybe NonEmpty where
   unwrap (_ :| [])       = Nothing
   unwrap (_ :| (a : as)) = Just (a :| as)
+
+instance ComonadCofree [] Tree where
+  unwrap = subForest
 
 instance ComonadCofree (Const b) ((,) b) where
   unwrap = Const . fst
diff --git a/src/Control/Comonad/Trans/Cofree.hs b/src/Control/Comonad/Trans/Cofree.hs
--- a/src/Control/Comonad/Trans/Cofree.hs
+++ b/src/Control/Comonad/Trans/Cofree.hs
@@ -3,6 +3,7 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE Rank2Types #-}
 #if __GLASGOW_HASKELL__ >= 707
 {-# LANGUAGE DeriveDataTypeable #-}
 #endif
@@ -26,6 +27,7 @@
   , ComonadCofree(..)
   , headF
   , tailF
+  , transCofreeT
   , coiterT
   ) where
 
@@ -33,6 +35,8 @@
 import Control.Comonad
 import Control.Comonad.Trans.Class
 import Control.Comonad.Cofree.Class
+import Control.Comonad.Env.Class
+import Control.Comonad.Hoist.Class
 import Control.Category
 import Data.Bifunctor
 import Data.Bifoldable
@@ -83,6 +87,10 @@
 instance Traversable f => Bitraversable (CofreeF f) where
   bitraverse f g (a :< as) = (:<) <$> f a <*> traverse g as
 
+transCofreeF :: (forall x. f x -> g x) -> CofreeF f a b -> CofreeF g a b
+transCofreeF t (a :< fb) = a :< t fb
+{-# INLINE transCofreeF #-}
+
 -- | This is a cofree comonad of some functor @f@, with a comonad @w@ threaded through it at each level.
 newtype CofreeT f w a = CofreeT { runCofreeT :: w (CofreeF f a (CofreeT f w a)) }
 #if __GLASGOW_HASKELL__ >= 707
@@ -138,6 +146,13 @@
 instance (Functor f, Comonad w) => ComonadCofree f (CofreeT f w) where
   unwrap = tailF . extract . runCofreeT
 
+instance (Functor f, ComonadEnv e w) => ComonadEnv e (CofreeT f w) where
+  ask = ask . lower
+  {-# INLINE ask #-} 
+
+instance Functor f => ComonadHoist (CofreeT f) where
+  cohoist g = CofreeT . fmap (second (cohoist g)) . g . runCofreeT
+
 instance Show (w (CofreeF f a (CofreeT f w a))) => Show (CofreeT f w a) where
   showsPrec d (CofreeT w) = showParen (d > 10) $
     showString "CofreeT " . showsPrec 11 w
@@ -153,8 +168,10 @@
   compare (CofreeT a) (CofreeT b) = compare a b
 
 instance (Alternative f, Monad w) => Monad (CofreeT f w) where
+#if __GLASGOW_HASKELL__ < 710
   return = CofreeT . return . (:< empty)
   {-# INLINE return #-}
+#endif
   CofreeT cx >>= f = CofreeT $ do
     a :< m <- cx
     b :< n <- runCofreeT $ f a
@@ -176,6 +193,10 @@
   mzip (CofreeT ma) (CofreeT mb) = CofreeT $ do
                                      (a :< fa, b :< fb) <- mzip ma mb
                                      return $ (a, b) :< (uncurry mzip <$> mzip fa fb)
+
+-- | Lift a natural transformation from @f@ to @g@ into a comonad homomorphism from @'CofreeT' f w@ to @'CofreeT' g w@
+transCofreeT :: (Functor g, Comonad w) => (forall x. f x -> g x) -> CofreeT f w a -> CofreeT g w a
+transCofreeT t = CofreeT . liftW (fmap (transCofreeT t) . transCofreeF t) . runCofreeT
 
 -- | Unfold a @CofreeT@ comonad transformer from a coalgebra and an initial comonad.
 coiterT :: (Functor f, Comonad w) => (w a -> f (w a)) -> w a -> CofreeT f w a
diff --git a/src/Control/Monad/Free.hs b/src/Control/Monad/Free.hs
--- a/src/Control/Monad/Free.hs
+++ b/src/Control/Monad/Free.hs
@@ -28,6 +28,7 @@
   , retract
   , liftF
   , iter
+  , iterA
   , iterM
   , hoistFree
   , foldFree
@@ -186,7 +187,7 @@
   Free m >>- f = Free ((>>- f) <$> m)
 
 instance Functor f => Monad (Free f) where
-  return = Pure
+  return = pure
   {-# INLINE return #-}
   Pure a >>= f = f a
   Free m >>= f = Free ((>>= f) <$> m)
@@ -303,17 +304,22 @@
 iter _ (Pure a) = a
 iter phi (Free m) = phi (iter phi <$> m)
 
--- | Like iter for monadic values.
+-- | Like 'iter' for applicative values.
+iterA :: (Applicative p, Functor f) => (f (p a) -> p a) -> Free f a -> p a
+iterA _   (Pure x) = pure x
+iterA phi (Free f) = phi (iterA phi <$> f)
+
+-- | Like 'iter' for monadic values.
 iterM :: (Monad m, Functor f) => (f (m a) -> m a) -> Free f a -> m a
 iterM _   (Pure x) = return x
-iterM phi (Free f) = phi $ fmap (iterM phi) f
+iterM phi (Free f) = phi (iterM phi <$> f)
 
 -- | Lift a natural transformation from @f@ to @g@ into a natural transformation from @'FreeT' f@ to @'FreeT' g@.
 hoistFree :: Functor g => (forall a. f a -> g a) -> Free f b -> Free g b
 hoistFree _ (Pure a)  = Pure a
 hoistFree f (Free as) = Free (hoistFree f <$> f as)
 
--- | The very definition of a free monoid is that given a natural transformation you get a monoid homomorphism.
+-- | The very definition of a free monad is that given a natural transformation you get a monad homomorphism.
 foldFree :: (Functor m, Monad m) => (forall x . f x -> m x) -> Free f a -> m a
 foldFree _ (Pure a)  = return a
 foldFree f (Free as) = f as >>= foldFree f
diff --git a/src/Control/Monad/Free/Church.hs b/src/Control/Monad/Free/Church.hs
--- a/src/Control/Monad/Free/Church.hs
+++ b/src/Control/Monad/Free/Church.hs
@@ -56,6 +56,7 @@
   ( F(..)
   , improve
   , fromF
+  , iter
   , iterM
   , toF
   , retract
@@ -69,7 +70,7 @@
 import Control.Applicative
 import Control.Monad as Monad
 import Control.Monad.Fix
-import Control.Monad.Free hiding (retract, iterM, cutoff)
+import Control.Monad.Free hiding (retract, iter, iterM, cutoff)
 import qualified Control.Monad.Free as Free
 import Control.Monad.Reader.Class
 import Control.Monad.Writer.Class
@@ -87,6 +88,10 @@
 -- <http://comonad.com/reader/2011/free-monads-for-less-2/>
 newtype F f a = F { runF :: forall r. (a -> r) -> (f r -> r) -> r }
 
+-- | Tear down a 'Free' 'Monad' using iteration.
+iter :: Functor f => (f a -> a) -> F f a -> a
+iter phi xs = runF xs id phi
+
 -- | Like iter for monadic values.
 iterM :: (Monad m, Functor f) => (f (m a) -> m a) -> F f a -> m a
 iterM phi xs = runF xs return phi
@@ -110,7 +115,7 @@
   (>>-) = (>>=)
 
 instance Monad (F f) where
-  return a = F (\kp _ -> kp a)
+  return = pure
   F m >>= f = F (\kp kf -> m (\a -> runF (f a) kp kf) kf)
 
 instance MonadFix (F f) where
@@ -169,7 +174,7 @@
 hoistF :: (forall x. f x -> g x) -> F f a -> F g a
 hoistF t (F m) = F (\p f -> m p (f . t))
 
--- | The very definition of a free monoid is that given a natural transformation you get a monoid homomorphism.
+-- | The very definition of a free monad is that given a natural transformation you get a monad homomorphism.
 foldF :: Monad m => (forall x. f x -> m x) -> F f a -> m a
 foldF f (F m) = m return (Monad.join . f)
 
diff --git a/src/Control/Monad/Free/Class.hs b/src/Control/Monad/Free/Class.hs
--- a/src/Control/Monad/Free/Class.hs
+++ b/src/Control/Monad/Free/Class.hs
@@ -43,6 +43,7 @@
 import Control.Monad.Trans.Maybe
 import Control.Monad.Trans.List
 import Control.Monad.Trans.Error
+import Control.Monad.Trans.Except
 import Control.Monad.Trans.Identity
 
 #if !(MIN_VERSION_base(4,8,0))
@@ -143,6 +144,9 @@
 
 instance (Functor f, MonadFree f m, Error e) => MonadFree f (ErrorT e m) where
   wrap = ErrorT . wrap . fmap runErrorT
+
+instance (Functor f, MonadFree f m) => MonadFree f (ExceptT e m) where
+  wrap = ExceptT . wrap . fmap runExceptT
 
 -- instance (Functor f, MonadFree f m) => MonadFree f (EitherT e m) where
 --   wrap = EitherT . wrap . fmap runEitherT
diff --git a/src/Control/Monad/Free/TH.hs b/src/Control/Monad/Free/TH.hs
--- a/src/Control/Monad/Free/TH.hs
+++ b/src/Control/Monad/Free/TH.hs
@@ -195,7 +195,11 @@
         -> Maybe [Name]     -- ^ Include only mentioned constructor names. Use all constructors when @Nothing@.
         -> Dec              -- ^ Data type declaration.
         -> Q [Dec]
+#if MIN_VERSION_template_haskell(2,11,0)
+liftDec typeSig onlyCons (DataD _ tyName tyVarBndrs _ cons _)
+#else
 liftDec typeSig onlyCons (DataD _ tyName tyVarBndrs cons _)
+#endif
   | null tyVarBndrs = fail $ "Type " ++ show tyName ++ " needs at least one free variable"
   | otherwise = concat <$> mapM (liftCon typeSig [] [] con nextTyName (init tyNames)) cons'
     where
@@ -232,7 +236,11 @@
 genFreeCon typeSig cname = do
   info <- reify cname
   case info of
-    DataConI _ _ tname _ -> genFree typeSig (Just [cname]) tname
+    DataConI _ _ tname
+#if !(MIN_VERSION_template_haskell(2,11,0))
+                       _
+#endif
+                         -> genFree typeSig (Just [cname]) tname
     _ -> fail "makeFreeCon expects a data constructor"
 
 -- | @$('makeFree' ''T)@ provides free monadic actions for the
@@ -240,7 +248,7 @@
 makeFree :: Name -> Q [Dec]
 makeFree = genFree True Nothing
 
--- | Like 'makeFreeCon', but does not provide type signatures.
+-- | Like 'makeFree', but does not provide type signatures.
 -- This can be used to attach Haddock comments to individual arguments
 -- for each generated function.
 --
diff --git a/src/Control/Monad/Trans/Free.hs b/src/Control/Monad/Trans/Free.hs
--- a/src/Control/Monad/Trans/Free.hs
+++ b/src/Control/Monad/Trans/Free.hs
@@ -224,7 +224,7 @@
 
 instance (Functor f, Monad m) => Monad (FreeT f m) where
   fail e = FreeT (fail e)
-  return a = FreeT (return (Pure a))
+  return = pure
   {-# INLINE return #-}
   FreeT m >>= f = FreeT $ m >>= \v -> case v of
     Pure a -> runFreeT (f a)
@@ -332,7 +332,7 @@
 hoistFreeT :: (Monad m, Functor f) => (forall a. m a -> n a) -> FreeT f m b -> FreeT f n b
 hoistFreeT mh = FreeT . mh . liftM (fmap (hoistFreeT mh)) . runFreeT
 
--- | Lift a natural transformation from @f@ to @g@ into a monad homomorphism from @'FreeT' f m@ to @'FreeT' g n@
+-- | Lift a natural transformation from @f@ to @g@ into a monad homomorphism from @'FreeT' f m@ to @'FreeT' g m@
 transFreeT :: (Monad m, Functor g) => (forall a. f a -> g a) -> FreeT f m b -> FreeT g m b
 transFreeT nt = FreeT . liftM (fmap (transFreeT nt) . transFreeF nt) . runFreeT
 
diff --git a/src/Control/Monad/Trans/Iter.hs b/src/Control/Monad/Trans/Iter.hs
--- a/src/Control/Monad/Trans/Iter.hs
+++ b/src/Control/Monad/Trans/Iter.hs
@@ -172,7 +172,7 @@
   {-# INLINE (<*>) #-}
 
 instance Monad m => Monad (IterT m) where
-  return = IterT . return . Left
+  return = pure
   {-# INLINE return #-}
   IterT m >>= k = IterT $ m >>= either (runIterT . k) (return . Right . (>>= k))
   {-# INLINE (>>=) #-}