diff --git a/kan-extensions.cabal b/kan-extensions.cabal
--- a/kan-extensions.cabal
+++ b/kan-extensions.cabal
@@ -1,6 +1,6 @@
 name:          kan-extensions
 category:      Data Structures, Monads, Comonads, Functors
-version:       3.0
+version:       3.1
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -34,7 +34,7 @@
     TypeFamilies
 
   build-depends:
-    adjunctions            == 3.0.*,
+    adjunctions            >= 3.0.0.1 && < 3.1,
     array                  >= 0.3.0.2 && < 0.5,
     base                   == 4.*,
     comonad                == 3.0.*,
@@ -43,10 +43,10 @@
     containers             >= 0.4     && < 0.6,
     contravariant          >= 0.2.0.1 && < 0.3,
     distributive           >= 0.2.2   && < 0.3,
-    free                   == 3.0.*,
+    free                   >= 3.0     && < 3.3,
     keys                   == 3.0.*,
     mtl                    >= 2.0.1   && < 2.2,
-    representable-functors == 3.0.*,
+    representable-functors >= 3.0.0.1 && < 3.1,
     semigroupoids          == 3.0.*,
     speculation            >= 1.4.1   && < 1.5,
     transformers           >= 0.2     && < 0.4
@@ -55,7 +55,6 @@
     Control.Comonad.Density
     Control.Monad.Co
     Control.Monad.Codensity
-    Control.Monad.Free.Church
     Data.Functor.KanExtension
     Data.Functor.Yoneda
     Data.Functor.Yoneda.Contravariant
diff --git a/src/Control/Monad/Codensity.hs b/src/Control/Monad/Codensity.hs
--- a/src/Control/Monad/Codensity.hs
+++ b/src/Control/Monad/Codensity.hs
@@ -26,6 +26,7 @@
 import Control.Monad (ap, MonadPlus(..))
 import Data.Functor.Adjunction
 import Data.Functor.Apply
+import Data.Functor.Plus
 import Control.Monad.Trans.Class
 import Control.Monad.IO.Class
 import Control.Concurrent.Speculation
@@ -56,6 +57,22 @@
 
 instance MonadTrans Codensity where
   lift m = Codensity (m >>=)
+
+instance Alt v => Alt (Codensity v) where
+  Codensity m <!> Codensity n = Codensity (\k -> m k <!> n k)
+
+instance Plus v => Plus (Codensity v) where
+  zero = Codensity (const zero)
+
+{-
+instance Plus v => Alternative (Codensity v) where
+  empty = zero
+  (<|>) = (<!>)
+
+instance Plus v => MonadPlus (Codensity v) where
+  mzero = zero
+  mplus = (<!>)
+-}
 
 instance Alternative v => Alternative (Codensity v) where
   empty                         = Codensity (\_ -> empty)
diff --git a/src/Control/Monad/Free/Church.hs b/src/Control/Monad/Free/Church.hs
deleted file mode 100644
--- a/src/Control/Monad/Free/Church.hs
+++ /dev/null
@@ -1,99 +0,0 @@
-{-# LANGUAGE Rank2Types, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Free.Church
--- Copyright   :  (C) 2011 Edward Kmett
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  Edward Kmett <ekmett@gmail.com>
--- Stability   :  provisional
--- Portability :  non-portable (rank-2 polymorphism)
---
--- Free Monads for Less
---
--- http://comonad.com/reader/2011/free-monads-for-less-2/
---
-----------------------------------------------------------------------------
-module Control.Monad.Free.Church
-  ( F(..)
-  , improve
-  , fromF
-  , toF
-  , liftF
-  , retract
-  ) where
-
-import Control.Applicative
-import Control.Monad
-import Control.Monad.Free hiding (liftF, retract)
-import Control.Monad.Reader.Class
-import Control.Monad.Writer.Class
-import Control.Monad.Cont.Class
-import Control.Monad.Trans.Class
-import Control.Monad.State.Class
-import Control.Concurrent.Speculation
-import Control.Concurrent.Speculation.Class
-
-instance MonadSpec (F f) where
-  specByM f g a = F (\k _ -> specBy f g k a)
-  specByM' f g a = F (\k _ -> specBy' f g k a)
-
-newtype F f a = F { runF :: forall r. (a -> r) -> (f r -> r) -> r }
-
-instance Functor (F f) where
-   fmap f (F g) = F (\kp -> g (kp . f))
-
-instance Applicative (F f) where
-   pure a = F (\kp _ -> kp a)
-   F f <*> F g = F (\kp kf -> f (\a -> g (\b -> kp (a b)) kf) kf)
-
-instance Alternative f => Alternative (F f) where
-   empty = F (\_ kf -> kf empty)
-   F f <|> F g = F (\kp kf -> kf (pure (f kp kf) <|> pure (g kp kf)))
-
-instance Monad (F f) where
-   return a = F (\kp _ -> kp a)
-   F m >>= f = F (\kp kf -> m (\a -> runF (f a) kp kf) kf)
-
-instance MonadPlus f => MonadPlus (F f) where
-   mzero = F (\_ kf -> kf mzero)
-   F f `mplus` F g = F (\kp kf -> kf (return (f kp kf) `mplus` return (g kp kf)))
-
-instance MonadTrans F where
-   lift f = F (\kp kf -> kf (liftM kp f))
-
-instance Functor f => MonadFree f (F f) where
-   wrap f = F (\kp kf -> kf (fmap (\ (F m) -> m kp kf) f))
-
-instance MonadState s m => MonadState s (F m) where
-   get = lift get
-   put = lift . put
-
-instance MonadReader e m => MonadReader e (F m) where
-   ask = lift ask 
-   local f = lift . local f . retract
-
-instance MonadWriter w m => MonadWriter w (F m) where
-   tell = lift . tell
-   pass = lift . pass . retract
-   listen = lift . listen . retract
-
-instance MonadCont m => MonadCont (F m) where
-   callCC f = lift $ callCC (retract . f . fmap lift)
-
-liftF :: Functor f => f a -> F f a
-liftF f = F (\kp kf -> kf (fmap kp f))
-
-retract :: Monad m => F m a -> m a
-retract (F m) = m return join
-
-fromF :: MonadFree f m => F f a -> m a
-fromF (F m) = m return wrap
-
-toF :: Functor f => Free f a -> F f a
-toF xs = F (\kp kf -> go kp kf xs) where
-  go kp _  (Pure a) = kp a
-  go kp kf (Free fma) = kf (fmap (go kp kf) fma)
-
-improve :: Functor f => (forall m. MonadFree f m => m a) -> Free f a
-improve m = fromF m