diff --git a/Control/Comonad/Density.hs b/Control/Comonad/Density.hs
--- a/Control/Comonad/Density.hs
+++ b/Control/Comonad/Density.hs
@@ -15,36 +15,36 @@
 -- ''Formal Theory of Monads''.
 ----------------------------------------------------------------------------
 module Control.Comonad.Density
-  ( DensityT(..)
-  , liftDensityT
-  , densityTToAdjunction, adjunctionToDensityT
+  ( Density(..)
+  , liftDensity
+  , densityToAdjunction, adjunctionToDensity
   ) where
 
 import Control.Comonad
 import Control.Comonad.Trans.Class
 import Data.Functor.Adjunction
 
-data DensityT k a where
-  DensityT :: (k b -> a) -> k b -> DensityT k a
+data Density k a where
+  Density :: (k b -> a) -> k b -> Density k a
 
-instance Functor (DensityT f) where
-  fmap f (DensityT g h) = DensityT (f . g) h
+instance Functor (Density f) where
+  fmap f (Density g h) = Density (f . g) h
 
-instance Extend (DensityT f) where
-  duplicate (DensityT f ws) = DensityT (DensityT f) ws
+instance Extend (Density f) where
+  duplicate (Density f ws) = Density (Density f) ws
 
-instance Comonad (DensityT f) where
-  extract (DensityT f a) = f a
+instance Comonad (Density f) where
+  extract (Density f a) = f a
 
-instance ComonadTrans DensityT where
-  lower (DensityT f c) = extend f c
+instance ComonadTrans Density where
+  lower (Density f c) = extend f c
   
 -- | The natural isomorphism between a comonad w and the comonad generated by w (forwards).
-liftDensityT :: Comonad w => w a -> DensityT w a
-liftDensityT = DensityT extract 
+liftDensity :: Comonad w => w a -> Density w a
+liftDensity = Density extract 
 
-densityTToAdjunction :: Adjunction f g => DensityT f a -> f (g a)
-densityTToAdjunction (DensityT f v) = fmap (leftAdjunct f) v
+densityToAdjunction :: Adjunction f g => Density f a -> f (g a)
+densityToAdjunction (Density f v) = fmap (leftAdjunct f) v
 
-adjunctionToDensityT :: Adjunction f g => f (g a) -> DensityT f a
-adjunctionToDensityT = DensityT counit
+adjunctionToDensity :: Adjunction f g => f (g a) -> Density f a
+adjunctionToDensity = Density counit
diff --git a/Control/Monad/Codensity.hs b/Control/Monad/Codensity.hs
--- a/Control/Monad/Codensity.hs
+++ b/Control/Monad/Codensity.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE Rank2Types, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.Codensity
@@ -11,60 +11,65 @@
 --
 ----------------------------------------------------------------------------
 module Control.Monad.Codensity
-  ( CodensityT(..)
-  , lowerCodensityT
-  , codensityTToAdjunction
-  , adjunctionToCodensityT
+  ( Codensity(..)
+  , lowerCodensity
+  , codensityToAdjunction
+  , adjunctionToCodensity
   ) where
 
 import Control.Applicative
+import Control.Monad.Reader.Class
+import Control.Monad.State.Class
+import Control.Monad.Free.Class
 import Control.Monad (ap, MonadPlus(..))
 import Data.Functor.Adjunction
 import Data.Functor.Apply
 import Control.Monad.Trans.Class
 import Control.Monad.IO.Class
 
-{-
-type Codensity = CodensityT Identity
-codensity :: (forall b. (a -> b) -> b) -> Codensity a
-runCodensity :: Codensity a -> (a -> b) -> a
--}
-
-newtype CodensityT m a = CodensityT { runCodensityT :: forall b. (a -> m b) -> m b }
+newtype Codensity m a = Codensity { runCodensity :: forall b. (a -> m b) -> m b }
 
-instance Functor (CodensityT k) where
-  fmap f (CodensityT m) = CodensityT (\k -> m (k . f))
+instance Functor (Codensity k) where
+  fmap f (Codensity m) = Codensity (\k -> m (k . f))
 
-instance Apply (CodensityT f) where
+instance Apply (Codensity f) where
   (<.>) = ap
 
-instance Applicative (CodensityT f) where
-  pure x = CodensityT (\k -> k x)
+instance Applicative (Codensity f) where
+  pure x = Codensity (\k -> k x)
   (<*>) = ap
 
-instance Monad (CodensityT f) where
-  return x = CodensityT (\k -> k x)
-  m >>= k = CodensityT (\c -> runCodensityT m (\a -> runCodensityT (k a) c))
+instance Monad (Codensity f) where
+  return x = Codensity (\k -> k x)
+  m >>= k = Codensity (\c -> runCodensity m (\a -> runCodensity (k a) c))
 
-instance MonadIO m => MonadIO (CodensityT m) where
+instance MonadIO m => MonadIO (Codensity m) where
   liftIO = lift . liftIO 
 
-instance MonadTrans CodensityT where
-  lift m = CodensityT (m >>=)
+instance MonadTrans Codensity where
+  lift m = Codensity (m >>=)
 
-instance Alternative v => Alternative (CodensityT v) where
-  empty                         = CodensityT (\_ -> empty)
-  CodensityT m <|> CodensityT n = CodensityT (\k -> m k <|> n k)
+instance Alternative v => Alternative (Codensity v) where
+  empty                         = Codensity (\_ -> empty)
+  Codensity m <|> Codensity n = Codensity (\k -> m k <|> n k)
 
-instance MonadPlus v => MonadPlus (CodensityT v) where
-  mzero                             = CodensityT (\_ -> mzero)
-  CodensityT m `mplus` CodensityT n = CodensityT (\k -> m k `mplus` n k)
+instance MonadPlus v => MonadPlus (Codensity v) where
+  mzero                             = Codensity (\_ -> mzero)
+  Codensity m `mplus` Codensity n = Codensity (\k -> m k `mplus` n k)
  
-lowerCodensityT :: Monad m => CodensityT m a -> m a
-lowerCodensityT a = runCodensityT a return
+lowerCodensity :: Monad m => Codensity m a -> m a
+lowerCodensity a = runCodensity a return
 
-codensityTToAdjunction :: Adjunction f g => CodensityT g a -> g (f a)
-codensityTToAdjunction r = runCodensityT r unit
+codensityToAdjunction :: Adjunction f g => Codensity g a -> g (f a)
+codensityToAdjunction r = runCodensity r unit
 
-adjunctionToCodensityT :: Adjunction f g => g (f a) -> CodensityT g a
-adjunctionToCodensityT f = CodensityT (\a -> fmap (rightAdjunct a) f)
+adjunctionToCodensity :: Adjunction f g => g (f a) -> Codensity g a
+adjunctionToCodensity f = Codensity (\a -> fmap (rightAdjunct a) f)
+
+instance MonadFree f m => MonadFree f (Codensity m) where
+  wrap t = Codensity (\h -> wrap (fmap (\p -> runCodensity p h) t))
+
+instance MonadReader r m => MonadState r (Codensity m) where
+  get = Codensity (ask >>=)
+  put s = Codensity (\k -> local (const s) (k ()))
+
diff --git a/Data/Functor/Yoneda.hs b/Data/Functor/Yoneda.hs
--- a/Data/Functor/Yoneda.hs
+++ b/Data/Functor/Yoneda.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE TypeFamilies, CPP, Rank2Types, FlexibleContexts, MultiParamTypeClasses, UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies, CPP, Rank2Types, FlexibleContexts, MultiParamTypeClasses, UndecidableInstances, FlexibleInstances #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Functor.Yoneda
@@ -12,20 +12,16 @@
 ----------------------------------------------------------------------------
 
 module Data.Functor.Yoneda
-  ( Yoneda
-  , yoneda
-  , runYoneda
+  ( Yoneda(..)
   , liftYoneda
   , lowerYoneda
-  , YonedaT(..)
-  , liftYonedaT
-  , lowerYonedaT
   , maxF, minF, maxM, minM
   ) where
 
 import Control.Applicative
 import Control.Monad (MonadPlus(..), liftM)
 import Control.Monad.Fix
+import Control.Monad.Free.Class
 import Control.Monad.Representable
 import Control.Monad.Trans.Class
 import Control.Comonad
@@ -34,7 +30,6 @@
 import Data.Foldable
 import Data.Function (on)
 import Data.Functor.Plus
-import Data.Functor.Identity
 import Data.Functor.Bind
 import Data.Functor.Adjunction
 import Data.Key
@@ -45,161 +40,146 @@
 import Text.Read hiding (lift)
 import Prelude hiding (sequence, lookup)
 
-type Yoneda = YonedaT Identity 
-
-yoneda :: (forall b. (a -> b) -> b) -> Yoneda a
-yoneda f = YonedaT (Identity . f)
-{-# INLINE yoneda #-}
-
-runYoneda :: Yoneda a -> (a -> b) -> b
-runYoneda (YonedaT f) = runIdentity . f
-{-# INLINE runYoneda #-}
-
-liftYoneda :: a -> Yoneda a
-liftYoneda a = YonedaT (\f -> Identity (f a))
-{-# INLINE liftYoneda #-}
-
-lowerYoneda :: Yoneda a -> a
-lowerYoneda m = runIdentity (runYonedaT m id)
-{-# INLINE lowerYoneda #-}
-
-newtype YonedaT f a = YonedaT { runYonedaT :: forall b. (a -> b) -> f b } 
+newtype Yoneda f a = Yoneda { runYoneda :: forall b. (a -> b) -> f b } 
 
-liftYonedaT :: Functor f => f a -> YonedaT f a 
-liftYonedaT a = YonedaT (\f -> fmap f a)
+liftYoneda :: Functor f => f a -> Yoneda f a 
+liftYoneda a = Yoneda (\f -> fmap f a)
 
-lowerYonedaT :: YonedaT f a -> f a 
-lowerYonedaT (YonedaT f) = f id
+lowerYoneda :: Yoneda f a -> f a 
+lowerYoneda (Yoneda f) = f id
 
-{-# RULES "lower/lift=id" liftYonedaT . lowerYonedaT = id #-}
-{-# RULES "lift/lower=id" lowerYonedaT . liftYonedaT = id #-}
+{-# RULES "lower/lift=id" liftYoneda . lowerYoneda = id #-}
+{-# RULES "lift/lower=id" lowerYoneda . liftYoneda = id #-}
 
-instance Functor (YonedaT f) where
-  fmap f m = YonedaT (\k -> runYonedaT m (k . f))
+instance Functor (Yoneda f) where
+  fmap f m = Yoneda (\k -> runYoneda m (k . f))
 
-type instance Key (YonedaT f) = Key f
+type instance Key (Yoneda f) = Key f
 
-instance Keyed f => Keyed (YonedaT f) where
-  mapWithKey f = liftYonedaT . mapWithKey f . lowerYonedaT 
+instance Keyed f => Keyed (Yoneda f) where
+  mapWithKey f = liftYoneda . mapWithKey f . lowerYoneda 
 
-instance Apply f => Apply (YonedaT f) where
-  YonedaT m <.> YonedaT n = YonedaT (\f -> m (f .) <.> n id)
+instance Apply f => Apply (Yoneda f) where
+  Yoneda m <.> Yoneda n = Yoneda (\f -> m (f .) <.> n id)
   
-instance Applicative f => Applicative (YonedaT f) where
-  pure a = YonedaT (\f -> pure (f a))
-  YonedaT m <*> YonedaT n = YonedaT (\f -> m (f .) <*> n id)
+instance Applicative f => Applicative (Yoneda f) where
+  pure a = Yoneda (\f -> pure (f a))
+  Yoneda m <*> Yoneda n = Yoneda (\f -> m (f .) <*> n id)
 
-instance Foldable f => Foldable (YonedaT f) where
-  foldMap f = foldMap f . lowerYonedaT
+instance Foldable f => Foldable (Yoneda f) where
+  foldMap f = foldMap f . lowerYoneda
 
-instance Foldable1 f => Foldable1 (YonedaT f) where
-  foldMap1 f = foldMap1 f . lowerYonedaT
+instance Foldable1 f => Foldable1 (Yoneda f) where
+  foldMap1 f = foldMap1 f . lowerYoneda
 
-instance FoldableWithKey f => FoldableWithKey (YonedaT f) where
-  foldMapWithKey f = foldMapWithKey f . lowerYonedaT
+instance FoldableWithKey f => FoldableWithKey (Yoneda f) where
+  foldMapWithKey f = foldMapWithKey f . lowerYoneda
 
-instance FoldableWithKey1 f => FoldableWithKey1 (YonedaT f) where
-  foldMapWithKey1 f = foldMapWithKey1 f . lowerYonedaT
+instance FoldableWithKey1 f => FoldableWithKey1 (Yoneda f) where
+  foldMapWithKey1 f = foldMapWithKey1 f . lowerYoneda
 
-instance Traversable f => Traversable (YonedaT f) where
-  traverse f = fmap liftYonedaT . traverse f . lowerYonedaT
+instance Traversable f => Traversable (Yoneda f) where
+  traverse f = fmap liftYoneda . traverse f . lowerYoneda
 
-instance TraversableWithKey f => TraversableWithKey (YonedaT f) where
-  traverseWithKey f = fmap liftYonedaT . traverseWithKey f . lowerYonedaT
+instance TraversableWithKey f => TraversableWithKey (Yoneda f) where
+  traverseWithKey f = fmap liftYoneda . traverseWithKey f . lowerYoneda
 
-instance Traversable1 f => Traversable1 (YonedaT f) where
-  traverse1 f = fmap liftYonedaT . traverse1 f . lowerYonedaT
+instance Traversable1 f => Traversable1 (Yoneda f) where
+  traverse1 f = fmap liftYoneda . traverse1 f . lowerYoneda
 
-instance TraversableWithKey1 f => TraversableWithKey1 (YonedaT f) where
-  traverseWithKey1 f = fmap liftYonedaT . traverseWithKey1 f . lowerYonedaT
+instance TraversableWithKey1 f => TraversableWithKey1 (Yoneda f) where
+  traverseWithKey1 f = fmap liftYoneda . traverseWithKey1 f . lowerYoneda
 
-instance Distributive f => Distributive (YonedaT f) where
-  collect f = liftYonedaT . collect (lowerYonedaT . f)
+instance Distributive f => Distributive (Yoneda f) where
+  collect f = liftYoneda . collect (lowerYoneda . f)
 
-instance Indexable f => Indexable (YonedaT f) where
-  index = index . lowerYonedaT
+instance Indexable f => Indexable (Yoneda f) where
+  index = index . lowerYoneda
 
-instance Lookup f => Lookup (YonedaT f) where
-  lookup i = lookup i . lowerYonedaT
+instance Lookup f => Lookup (Yoneda f) where
+  lookup i = lookup i . lowerYoneda
 
-instance Representable g => Representable (YonedaT g) where
-  tabulate = liftYonedaT . tabulate
+instance Representable g => Representable (Yoneda g) where
+  tabulate = liftYoneda . tabulate
 
-instance Adjunction f g => Adjunction (YonedaT f) (YonedaT g) where
-  unit = liftYonedaT . fmap liftYonedaT . unit
-  counit (YonedaT m) = counit (m lowerYonedaT)
+instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g) where
+  unit = liftYoneda . fmap liftYoneda . unit
+  counit (Yoneda m) = counit (m lowerYoneda)
 
--- instance Show1 f => Show1 (YonedaT f) where
-instance Show (f a) => Show (YonedaT f a) where
-  showsPrec d (YonedaT f) = showParen (d > 10) $
-    showString "liftYonedaT " . showsPrec 11 (f id)
+-- instance Show1 f => Show1 (Yoneda f) where
+instance Show (f a) => Show (Yoneda f a) where
+  showsPrec d (Yoneda f) = showParen (d > 10) $
+    showString "liftYoneda " . showsPrec 11 (f id)
 
--- instance Read1 f => Read1 (YonedaT f) where
+-- instance Read1 f => Read1 (Yoneda f) where
 #ifdef __GLASGOW_HASKELL__
-instance (Functor f, Read (f a)) => Read (YonedaT f a) where
+instance (Functor f, Read (f a)) => Read (Yoneda f a) where
   readPrec = parens $ prec 10 $ do
-     Ident "liftYonedaT" <- lexP
-     liftYonedaT <$> step readPrec
+     Ident "liftYoneda" <- lexP
+     liftYoneda <$> step readPrec
 #endif
 
-instance Eq (f a) => Eq (YonedaT f a) where
-  (==) = (==) `on` lowerYonedaT
+instance Eq (f a) => Eq (Yoneda f a) where
+  (==) = (==) `on` lowerYoneda
 
-instance Ord (f a) => Ord (YonedaT f a) where
-  compare = compare `on` lowerYonedaT
+instance Ord (f a) => Ord (Yoneda f a) where
+  compare = compare `on` lowerYoneda
 
-maxF :: (Functor f, Ord (f a)) => YonedaT f a -> YonedaT f a -> YonedaT f a
-YonedaT f `maxF` YonedaT g = liftYonedaT $ f id `max` g id
+maxF :: (Functor f, Ord (f a)) => Yoneda f a -> Yoneda f a -> Yoneda f a
+Yoneda f `maxF` Yoneda g = liftYoneda $ f id `max` g id
 -- {-# RULES "max/maxF" max = maxF #-}
 {-# INLINE maxF #-}
 
-minF :: (Functor f, Ord (f a)) => YonedaT f a -> YonedaT f a -> YonedaT f a
-YonedaT f `minF` YonedaT g = liftYonedaT $ f id `max` g id
+minF :: (Functor f, Ord (f a)) => Yoneda f a -> Yoneda f a -> Yoneda f a
+Yoneda f `minF` Yoneda g = liftYoneda $ f id `max` g id
 -- {-# RULES "min/minF" min = minF #-}
 {-# INLINE minF #-}
 
-maxM :: (Monad m, Ord (m a)) => YonedaT m a -> YonedaT m a -> YonedaT m a
-YonedaT f `maxM` YonedaT g = lift $ f id `max` g id
+maxM :: (Monad m, Ord (m a)) => Yoneda m a -> Yoneda m a -> Yoneda m a
+Yoneda f `maxM` Yoneda g = lift $ f id `max` g id
 -- {-# RULES "max/maxM" max = maxM #-}
 {-# INLINE maxM #-}
 
-minM :: (Monad m, Ord (m a)) => YonedaT m a -> YonedaT m a -> YonedaT m a
-YonedaT f `minM` YonedaT g = lift $ f id `min` g id
+minM :: (Monad m, Ord (m a)) => Yoneda m a -> Yoneda m a -> Yoneda m a
+Yoneda f `minM` Yoneda g = lift $ f id `min` g id
 -- {-# RULES "min/minM" min = minM #-}
 {-# INLINE minM #-}
 
-instance Alt f => Alt (YonedaT f) where
-  YonedaT f <!> YonedaT g = YonedaT (\k -> f k <!> g k)
+instance Alt f => Alt (Yoneda f) where
+  Yoneda f <!> Yoneda g = Yoneda (\k -> f k <!> g k)
 
-instance Plus f => Plus (YonedaT f) where
-  zero = YonedaT $ const zero
+instance Plus f => Plus (Yoneda f) where
+  zero = Yoneda $ const zero
 
-instance Alternative f => Alternative (YonedaT f) where
-  empty = YonedaT $ const empty
-  YonedaT f <|> YonedaT g = YonedaT (\k -> f k <|> g k)
+instance Alternative f => Alternative (Yoneda f) where
+  empty = Yoneda $ const empty
+  Yoneda f <|> Yoneda g = Yoneda (\k -> f k <|> g k)
 
-instance Bind m => Bind (YonedaT m) where
-  YonedaT m >>- k = YonedaT (\f -> m id >>- \a -> runYonedaT (k a) f)
+instance Bind m => Bind (Yoneda m) where
+  Yoneda m >>- k = Yoneda (\f -> m id >>- \a -> runYoneda (k a) f)
   
-instance Monad m => Monad (YonedaT m) where
-  return a = YonedaT (\f -> return (f a))
-  YonedaT m >>= k = YonedaT (\f -> m id >>= \a -> runYonedaT (k a) f)
+instance Monad m => Monad (Yoneda m) where
+  return a = Yoneda (\f -> return (f a))
+  Yoneda m >>= k = Yoneda (\f -> m id >>= \a -> runYoneda (k a) f)
 
-instance MonadFix m => MonadFix (YonedaT m) where
-  mfix f = lift $ mfix (lowerYonedaT . f)
+instance MonadFix m => MonadFix (Yoneda m) where
+  mfix f = lift $ mfix (lowerYoneda . f)
 
-instance MonadPlus m => MonadPlus (YonedaT m) where
-  mzero = YonedaT (const mzero)
-  YonedaT f `mplus` YonedaT g = YonedaT (\k -> f k `mplus` g k)
+instance MonadPlus m => MonadPlus (Yoneda m) where
+  mzero = Yoneda (const mzero)
+  Yoneda f `mplus` Yoneda g = Yoneda (\k -> f k `mplus` g k)
 
-instance MonadTrans YonedaT where
-  lift a = YonedaT (\f -> liftM f a)
+instance MonadTrans Yoneda where
+  lift a = Yoneda (\f -> liftM f a)
 
-instance Extend w => Extend (YonedaT w) where
-  extend k (YonedaT m) = YonedaT (\f -> extend (f . k . liftYonedaT) (m id))
+instance MonadFree f m => MonadFree f (Yoneda m) where
+  wrap = lift . wrap . fmap lowerYoneda
 
-instance Comonad w => Comonad (YonedaT w) where
-  extract = extract . lowerYonedaT 
+instance Extend w => Extend (Yoneda w) where
+  extend k (Yoneda m) = Yoneda (\f -> extend (f . k . liftYoneda) (m id))
 
-instance ComonadTrans YonedaT where
-  lower = lowerYonedaT 
+instance Comonad w => Comonad (Yoneda w) where
+  extract = extract . lowerYoneda 
+
+instance ComonadTrans Yoneda where
+  lower = lowerYoneda 
diff --git a/Data/Functor/Yoneda/Contravariant.hs b/Data/Functor/Yoneda/Contravariant.hs
--- a/Data/Functor/Yoneda/Contravariant.hs
+++ b/Data/Functor/Yoneda/Contravariant.hs
@@ -11,14 +11,10 @@
 --
 ----------------------------------------------------------------------------
 module Data.Functor.Yoneda.Contravariant
-  ( Yoneda
-  , yoneda
+  ( Yoneda(..)
   , liftYoneda
   , lowerYoneda
-  , liftYonedaT
-  , lowerYonedaT
   , lowerM
-  , YonedaT(..)
   ) where
 
 import Control.Applicative
@@ -32,138 +28,129 @@
 import Data.Function (on)
 import Data.Functor.Bind
 import Data.Functor.Plus
-import Data.Functor.Identity
 import Data.Functor.Adjunction
 import Data.Key
-import Prelude hiding (sequence)
+import Prelude hiding (sequence, lookup)
 import Text.Read hiding (lift)
 
-type Yoneda = YonedaT Identity
-
 -- | The contravariant Yoneda lemma applied to a covariant functor
-data YonedaT f a where
-  YonedaT :: (b -> a) -> f b -> YonedaT f a
-
-yoneda :: (b -> a) -> b -> Yoneda a
-yoneda f = YonedaT f . Identity
-
-liftYoneda :: a -> Yoneda a 
-liftYoneda = YonedaT id . Identity
-
-lowerYoneda :: Yoneda a -> a
-lowerYoneda (YonedaT f (Identity a)) = f a
+data Yoneda f a where
+  Yoneda :: (b -> a) -> f b -> Yoneda f a
 
-liftYonedaT :: f a -> YonedaT f a 
-liftYonedaT = YonedaT id
+liftYoneda :: f a -> Yoneda f a 
+liftYoneda = Yoneda id
 
-lowerYonedaT :: Functor f => YonedaT f a -> f a
-lowerYonedaT (YonedaT f m) = fmap f m
+lowerYoneda :: Functor f => Yoneda f a -> f a
+lowerYoneda (Yoneda f m) = fmap f m
 
-lowerM :: Monad f => YonedaT f a -> f a 
-lowerM (YonedaT f m) = liftM f m
+lowerM :: Monad f => Yoneda f a -> f a 
+lowerM (Yoneda f m) = liftM f m
 
-instance Functor (YonedaT f) where
-  fmap f (YonedaT g v) = YonedaT (f . g) v
+instance Functor (Yoneda f) where
+  fmap f (Yoneda g v) = Yoneda (f . g) v
 
-type instance Key (YonedaT f) = Key f
+type instance Key (Yoneda f) = Key f
 
-instance Keyed f => Keyed (YonedaT f) where
-  mapWithKey f (YonedaT k a) = YonedaT id $ mapWithKey (\x -> f x . k) a
+instance Keyed f => Keyed (Yoneda f) where
+  mapWithKey f (Yoneda k a) = Yoneda id $ mapWithKey (\x -> f x . k) a
 
-instance Apply f => Apply (YonedaT f) where
-  m <.> n = liftYonedaT $ lowerYonedaT m <.> lowerYonedaT n
+instance Apply f => Apply (Yoneda f) where
+  m <.> n = liftYoneda $ lowerYoneda m <.> lowerYoneda n
 
-instance Applicative f => Applicative (YonedaT f) where
-  pure = liftYonedaT . pure
-  m <*> n = liftYonedaT $ lowerYonedaT m <*> lowerYonedaT n
+instance Applicative f => Applicative (Yoneda f) where
+  pure = liftYoneda . pure
+  m <*> n = liftYoneda $ lowerYoneda m <*> lowerYoneda n
 
-instance Alternative f => Alternative (YonedaT f) where
-  empty = liftYonedaT empty 
-  m <|> n = liftYonedaT $ lowerYonedaT m <|> lowerYonedaT n
+instance Alternative f => Alternative (Yoneda f) where
+  empty = liftYoneda empty 
+  m <|> n = liftYoneda $ lowerYoneda m <|> lowerYoneda n
 
-instance Alt f => Alt (YonedaT f) where
-  m <!> n = liftYonedaT $ lowerYonedaT m <!> lowerYonedaT n
+instance Alt f => Alt (Yoneda f) where
+  m <!> n = liftYoneda $ lowerYoneda m <!> lowerYoneda n
 
-instance Plus f => Plus (YonedaT f) where
-  zero = liftYonedaT zero
+instance Plus f => Plus (Yoneda f) where
+  zero = liftYoneda zero
 
-instance Bind m => Bind (YonedaT m) where
-  YonedaT f v >>- k = liftYonedaT (v >>- lowerYonedaT . k . f)
+instance Bind m => Bind (Yoneda m) where
+  Yoneda f v >>- k = liftYoneda (v >>- lowerYoneda . k . f)
 
-instance Monad m => Monad (YonedaT m) where
-  return = YonedaT id . return
-  YonedaT f v >>= k = lift (v >>= lowerM . k . f)
+instance Monad m => Monad (Yoneda m) where
+  return = Yoneda id . return
+  Yoneda f v >>= k = lift (v >>= lowerM . k . f)
 
-instance MonadTrans YonedaT where
-  lift = YonedaT id
+instance MonadTrans Yoneda where
+  lift = Yoneda id
 
-instance MonadFix f => MonadFix (YonedaT f) where
+instance MonadFix f => MonadFix (Yoneda f) where
   mfix f = lift $ mfix (lowerM . f)
 
-instance MonadPlus f => MonadPlus (YonedaT f) where
+instance MonadPlus f => MonadPlus (Yoneda f) where
   mzero = lift mzero
   m `mplus` n = lift $ lowerM m `mplus` lowerM n
 
-instance (Functor f, Indexable f) => Indexable (YonedaT f) where
-  index = index . lowerYonedaT
+instance (Functor f, Lookup f) => Lookup (Yoneda f) where
+  lookup k f = lookup k (lowerYoneda f)
 
-instance Representable f => Representable (YonedaT f) where
-  tabulate = liftYonedaT . tabulate
+instance (Functor f, Indexable f) => Indexable (Yoneda f) where
+  index = index . lowerYoneda
 
-instance Extend w => Extend (YonedaT w) where
-  extend k (YonedaT f v) = YonedaT id $ extend (k . YonedaT f) v
+instance Representable f => Representable (Yoneda f) where
+  tabulate = liftYoneda . tabulate
 
-instance Comonad w => Comonad (YonedaT w) where
-  extract (YonedaT f v) = f (extract v)
+instance Extend w => Extend (Yoneda w) where
+  extend k (Yoneda f v) = Yoneda id $ extend (k . Yoneda f) v
 
-instance ComonadTrans YonedaT where
-  lower (YonedaT f a) = fmap f a
+instance Comonad w => Comonad (Yoneda w) where
+  extract (Yoneda f v) = f (extract v)
 
-instance Foldable f => Foldable (YonedaT f) where
-  foldMap f (YonedaT k a) = foldMap (f . k) a
+instance ComonadTrans Yoneda where
+  lower (Yoneda f a) = fmap f a
 
-instance FoldableWithKey f => FoldableWithKey (YonedaT f) where
-  foldMapWithKey f (YonedaT k a) = foldMapWithKey (\x -> f x . k) a
+instance Foldable f => Foldable (Yoneda f) where
+  foldMap f (Yoneda k a) = foldMap (f . k) a
 
-instance Foldable1 f => Foldable1 (YonedaT f) where
-  foldMap1 f (YonedaT k a) = foldMap1 (f . k) a
+instance FoldableWithKey f => FoldableWithKey (Yoneda f) where
+  foldMapWithKey f (Yoneda k a) = foldMapWithKey (\x -> f x . k) a
 
-instance FoldableWithKey1 f => FoldableWithKey1 (YonedaT f) where
-  foldMapWithKey1 f (YonedaT k a) = foldMapWithKey1 (\x -> f x . k) a
+instance Foldable1 f => Foldable1 (Yoneda f) where
+  foldMap1 f (Yoneda k a) = foldMap1 (f . k) a
 
-instance Traversable f => Traversable (YonedaT f) where
-  traverse f (YonedaT k a) = YonedaT id <$> traverse (f . k) a
+instance FoldableWithKey1 f => FoldableWithKey1 (Yoneda f) where
+  foldMapWithKey1 f (Yoneda k a) = foldMapWithKey1 (\x -> f x . k) a
 
-instance Traversable1 f => Traversable1 (YonedaT f) where
-  traverse1 f (YonedaT k a) = YonedaT id <$> traverse1 (f . k) a
+instance Traversable f => Traversable (Yoneda f) where
+  traverse f (Yoneda k a) = Yoneda id <$> traverse (f . k) a
 
-instance TraversableWithKey f => TraversableWithKey (YonedaT f) where
-  traverseWithKey f (YonedaT k a) = YonedaT id <$> traverseWithKey (\x -> f x . k) a
+instance Traversable1 f => Traversable1 (Yoneda f) where
+  traverse1 f (Yoneda k a) = Yoneda id <$> traverse1 (f . k) a
 
-instance TraversableWithKey1 f => TraversableWithKey1 (YonedaT f) where
-  traverseWithKey1 f (YonedaT k a) = YonedaT id <$> traverseWithKey1 (\x -> f x . k) a
+instance TraversableWithKey f => TraversableWithKey (Yoneda f) where
+  traverseWithKey f (Yoneda k a) = Yoneda id <$> traverseWithKey (\x -> f x . k) a
 
-instance Distributive f => Distributive (YonedaT f) where
-  collect f = liftYonedaT . collect (lowerYonedaT . f)
+instance TraversableWithKey1 f => TraversableWithKey1 (Yoneda f) where
+  traverseWithKey1 f (Yoneda k a) = Yoneda id <$> traverseWithKey1 (\x -> f x . k) a
 
-instance (Functor f, Show (f a)) => Show (YonedaT f a) where
-  showsPrec d (YonedaT f a) = showParen (d > 10) $
-    showString "liftYonedaT " . showsPrec 11 (fmap f a)
+instance Distributive f => Distributive (Yoneda f) where
+  collect f = liftYoneda . collect (lowerYoneda . f)
 
+instance (Functor f, Show (f a)) => Show (Yoneda f a) where
+  showsPrec d (Yoneda f a) = showParen (d > 10) $
+    showString "liftYoneda " . showsPrec 11 (fmap f a)
+
 #ifdef __GLASGOW_HASKELL__
-instance (Functor f, Read (f a)) => Read (YonedaT f a) where
+instance (Functor f, Read (f a)) => Read (Yoneda f a) where
   readPrec = parens $ prec 10 $ do
-    Ident "liftYonedaT" <- lexP
-    liftYonedaT <$> step readPrec
+    Ident "liftYoneda" <- lexP
+    liftYoneda <$> step readPrec
 #endif
 
-instance (Functor f, Eq (f a)) => Eq (YonedaT f a) where
-  (==) = (==) `on` lowerYonedaT
+instance (Functor f, Eq (f a)) => Eq (Yoneda f a) where
+  (==) = (==) `on` lowerYoneda
 
-instance (Functor f, Ord (f a)) => Ord (YonedaT f a) where
-  compare = compare `on` lowerYonedaT
+instance (Functor f, Ord (f a)) => Ord (Yoneda f a) where
+  compare = compare `on` lowerYoneda
 
-instance Adjunction f g => Adjunction (YonedaT f) (YonedaT g) where
-  unit = liftYonedaT . fmap liftYonedaT . unit
-  counit = counit . fmap lowerYonedaT . lowerYonedaT
+instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g) where
+  unit = liftYoneda . fmap liftYoneda . unit
+  counit = counit . fmap lowerYoneda . lowerYoneda
 
diff --git a/kan-extensions.cabal b/kan-extensions.cabal
--- a/kan-extensions.cabal
+++ b/kan-extensions.cabal
@@ -1,13 +1,13 @@
 name:          kan-extensions
 category:      Data Structures, Monads, Comonads, Functors
-version:       0.2.2
+version:       0.5.0
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
 author:        Edward A. Kmett
 maintainer:    Edward A. Kmett <ekmett@gmail.com>
 stability:     provisional
-homepage:      http://github.com/ekmett/adjunctions/
+homepage:      http://github.com/ekmett/kan-extensions/
 copyright:     Copyright (C) 2011 Edward A. Kmett
 synopsis:      Kan extensions, the Yoneda lemma, and (co)density (co)monads
 description:   Kan extensions, the Yoneda lemma, and (co)density (co)monads
@@ -15,21 +15,22 @@
 
 source-repository head
   type: git
-  location: git://github.com/ekmett/adjunctions.git
+  location: git://github.com/ekmett/kan-extensions.git
 
 library
   build-depends: 
-    adjunctions >= 0.9.3 && < 0.10,
+    adjunctions >= 1.0.0 && < 1.0.1,
     array >= 0.3.0.2 && < 0.4,
     base >= 4 && < 4.4,
     comonad >= 1.1 && < 1.2,
-    comonad-transformers >= 1.6.3 && < 1.7,
+    comonads-fd >= 1.7 && < 1.8,
+    comonad-transformers >= 1.7 && < 1.8,
     containers >= 0.4 && < 0.5,
     contravariant >= 0.1.2 && < 0.2,
     distributive >= 0.2 && < 0.3,
-    keys >= 0.2.6 && < 0.3,
+    keys >= 0.3 && < 0.4,
     mtl >= 2.0.1.0 && < 2.1,
-    representable-functors >= 0.4.3 && < 0.5,
+    representable-functors >= 0.5 && < 0.6,
     semigroups >= 0.5 && < 0.6,
     semigroupoids >= 1.2.2 && < 1.3.0,
     transformers >= 0.2.0 && < 0.3