diff --git a/Control/Comonad/Contra.hs b/Control/Comonad/Contra.hs
deleted file mode 100644
--- a/Control/Comonad/Contra.hs
+++ /dev/null
@@ -1,46 +0,0 @@
-{-# LANGUAGE MultiParamTypeClasses #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Comonad.Contra
--- Copyright   :  (C) 2011 Edward Kmett
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  Edward Kmett <ekmett@gmail.com>
--- Stability   :  provisional
--- Portability :  MPTCs, fundeps
---
--- Use a contravariant dual adjunction from Hask^op to build a 'Monad' to 
--- 'Comonad' transformer.
-----------------------------------------------------------------------------
-
-module Control.Comonad.Contra
-  ( Contra
-  , runContra
-  , contra
-  , ContraT(..)
-  ) where
-
-import Prelude hiding (sequence)
-import Control.Comonad
-import Control.Monad (liftM)
-import Data.Functor.Identity
-import Data.Functor.Contravariant
-import Data.Functor.Contravariant.DualAdjunction
-
-type Contra f g = ContraT f g Identity
-
-newtype ContraT f g m a = ContraT { runContraT :: f (m (g a)) }
-
-contra :: Contravariant f => f (g a) -> Contra f g a
-contra = ContraT . contramap runIdentity
-
-runContra :: Contravariant f => Contra f g a -> f (g a)
-runContra = contramap Identity . runContraT
-
-instance (Contravariant f, Contravariant g, Monad m) => Functor (ContraT f g m) where
-  fmap f (ContraT g) = ContraT $ contramap (liftM (contramap f)) g
-  
-instance (DualAdjunction f g, Monad m) => Comonad (ContraT f g m) where
-  extract = rightAdjunctOp return . runContraT
-  extend f = ContraT . contramap (>>= leftAdjunctOp (f . ContraT)) . runContraT
-
diff --git a/Control/Comonad/Contra/Adjoint.hs b/Control/Comonad/Contra/Adjoint.hs
new file mode 100644
--- /dev/null
+++ b/Control/Comonad/Contra/Adjoint.hs
@@ -0,0 +1,46 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Comonad.Contra.Adjoint
+-- Copyright   :  (C) 2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  MPTCs
+--
+-- Use a contravariant dual adjunction from Hask^op to build a 'Monad' to 
+-- 'Comonad' transformer.
+----------------------------------------------------------------------------
+
+module Control.Comonad.Contra.Adjoint
+  ( Adjoint
+  , runAdjoint
+  , adjoint
+  , AdjointT(..)
+  ) where
+
+import Prelude hiding (sequence)
+import Control.Comonad
+import Control.Monad (liftM)
+import Data.Functor.Identity
+import Data.Functor.Contravariant
+import Data.Functor.Contravariant.DualAdjunction
+
+type Adjoint f g = AdjointT f g Identity
+
+newtype AdjointT f g m a = AdjointT { runAdjointT :: f (m (g a)) }
+
+adjoint :: Contravariant f => f (g a) -> Adjoint f g a
+adjoint = AdjointT . contramap runIdentity
+
+runAdjoint :: Contravariant f => Adjoint f g a -> f (g a)
+runAdjoint = contramap Identity . runAdjointT
+
+instance (Contravariant f, Contravariant g, Monad m) => Functor (AdjointT f g m) where
+  fmap f (AdjointT g) = AdjointT $ contramap (liftM (contramap f)) g
+  
+instance (DualAdjunction f g, Monad m) => Comonad (AdjointT f g m) where
+  extract = rightAdjunctOp return . runAdjointT
+  extend f = AdjointT . contramap (>>= leftAdjunctOp (f . AdjointT)) . runAdjointT
+
diff --git a/Control/Comonad/Trans/Density.hs b/Control/Comonad/Trans/Density.hs
new file mode 100644
--- /dev/null
+++ b/Control/Comonad/Trans/Density.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE MultiParamTypeClasses, GADTs #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Comonad.Density
+-- Copyright   :  (C) 2008-2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  experimental
+-- Portability :  non-portable (GADTs, MPTCs)
+--
+-- The density comonad for a functor. aka the comonad cogenerated by a functor
+-- The ''density'' term dates back to Dubuc''s 1974 thesis. The term 
+-- ''monad genererated by a functor'' dates back to 1972 in Street''s 
+-- ''Formal Theory of Monads''.
+----------------------------------------------------------------------------
+module Control.Comonad.Trans.Density
+  ( Density(..)
+  , liftDensity
+  , densityToAdjunction, adjunctionToDensity
+  ) where
+
+import Control.Comonad
+import Control.Comonad.Trans.Class
+import Data.Functor.Adjunction
+
+data Density k a where
+  Density :: (k b -> a) -> k b -> Density k a
+
+instance Functor (Density f) where
+  fmap f (Density g h) = Density (f . g) h
+
+instance Comonad (Density f) where
+  extract (Density f a) = f a
+  duplicate (Density f ws) = Density (Density f) ws
+
+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).
+liftDensity :: Comonad w => w a -> Density w a
+liftDensity = Density extract 
+
+densityToAdjunction :: Adjunction f g => Density f a -> f (g a)
+densityToAdjunction (Density f v) = fmap (leftAdjunct f) v
+
+adjunctionToDensity :: Adjunction f g => f (g a) -> Density f a
+adjunctionToDensity = Density counit
diff --git a/Control/Monad/Contra.hs b/Control/Monad/Contra.hs
deleted file mode 100644
--- a/Control/Monad/Contra.hs
+++ /dev/null
@@ -1,50 +0,0 @@
-{-# LANGUAGE MultiParamTypeClasses #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Contra
--- Copyright   :  (C) 2011 Edward Kmett
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  Edward Kmett <ekmett@gmail.com>
--- Stability   :  provisional
--- Portability :  MPTCs, fundeps
---
--- Use a contravariant adjunction to Hask^op to build a 'Comonad' to 
--- 'Monad' transformer.
-----------------------------------------------------------------------------
-
-module Control.Monad.Contra
-  ( Contra
-  , runContra
-  , contra
-  , ContraT(..)
-  ) where
-
-import Prelude hiding (sequence)
-import Control.Applicative
-import Control.Comonad
-import Control.Monad (ap)
-import Data.Functor.Identity
-import Data.Functor.Contravariant
-import Data.Functor.Contravariant.Adjunction
-
-type Contra f g = ContraT f g Identity
-
-newtype ContraT f g w a = ContraT { runContraT :: g (w (f a)) }
-
-contra :: Contravariant g => g (f a) -> Contra f g a
-contra = ContraT . contramap runIdentity
-
-runContra :: Contravariant g => Contra f g a -> g (f a)
-runContra = contramap Identity . runContraT
-
-instance (Adjunction f g, Functor w) => Functor (ContraT f g w) where
-  fmap f (ContraT g) = ContraT $ contramap (fmap (contramap f)) g
-  
-instance (Adjunction f g, Comonad w) => Applicative (ContraT f g w) where
-  pure = ContraT . leftAdjunct extract
-  (<*>) = ap
-
-instance (Adjunction f g, Comonad w) => Monad (ContraT f g w) where
-  return = ContraT . leftAdjunct extract
-  ContraT m >>= f = ContraT $ contramap (extend (rightAdjunct (runContraT . f))) m
diff --git a/Control/Monad/Contra/Adjoint.hs b/Control/Monad/Contra/Adjoint.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Contra/Adjoint.hs
@@ -0,0 +1,51 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.Contra.Adjoint
+-- Copyright   :  (C) 2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  MPTCs, fundeps
+--
+-- Use a contravariant adjunction to Hask^op to build a 'Comonad' to 
+-- 'Monad' transformer.
+----------------------------------------------------------------------------
+
+module Control.Monad.Contra.Adjoint
+  ( Adjoint
+  , runAdjoint
+  , adjoint
+  , AdjointT(..)
+  ) where
+
+import Prelude hiding (sequence)
+import Control.Applicative
+import Control.Comonad
+import Control.Monad (ap)
+import Data.Functor.Identity
+import Data.Functor.Contravariant
+import Data.Functor.Contravariant.Adjunction
+
+type Adjoint f g = AdjointT f g Identity
+
+newtype AdjointT f g w a = AdjointT { runAdjointT :: g (w (f a)) }
+
+adjoint :: Contravariant g => g (f a) -> Adjoint f g a
+adjoint = AdjointT . contramap runIdentity
+
+runAdjoint :: Contravariant g => Adjoint f g a -> g (f a)
+runAdjoint = contramap Identity . runAdjointT
+
+instance (Adjunction f g, Functor w) => Functor (AdjointT f g w) where
+  fmap f (AdjointT g) = AdjointT $ contramap (fmap (contramap f)) g
+  
+instance (Adjunction f g, Comonad w) => Applicative (AdjointT f g w) where
+  pure = AdjointT . leftAdjunct extract
+  (<*>) = ap
+
+instance (Adjunction f g, Comonad w) => Monad (AdjointT f g w) where
+  return = AdjointT . leftAdjunct extract
+  AdjointT m >>= f = AdjointT $ contramap (extend (rightAdjunct (runAdjointT . f))) m
+
diff --git a/Control/Monad/Contra/Cont.hs b/Control/Monad/Contra/Cont.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Contra/Cont.hs
@@ -0,0 +1,56 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.Contra.Cont
+-- Copyright   :  (C) 2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  MPTCs, fundeps
+--
+-- > ContT r ~ AdjointT (Op r) (Op r)
+----------------------------------------------------------------------------
+
+module Control.Monad.Contra.Cont
+  ( Cont
+  , runCont
+  , cont
+  , ContT(..)
+  , callCC
+  ) where
+
+import Prelude hiding (sequence)
+import Control.Applicative
+import Control.Comonad
+import Control.Monad (ap)
+import Data.Functor.Apply
+import Data.Functor.Identity
+
+type Cont r = ContT r Identity
+
+newtype ContT r w a = ContT { runContT :: w (a -> r) -> r }
+
+cont :: ((a -> r) -> r) -> Cont r a
+cont f = ContT $ f . runIdentity
+
+runCont :: Cont r a -> (a -> r) -> r
+runCont (ContT k) = k . Identity
+
+instance Functor w => Functor (ContT r w) where
+  fmap f (ContT k) = ContT $ k . fmap (. f)
+
+instance Comonad w => FunctorApply (ContT r w) where
+  (<.>) = ap
+  
+instance Comonad w => Applicative (ContT r w) where
+  pure x = ContT $ \wk -> extract wk x
+  (<*>) = ap
+
+instance Comonad w => Monad (ContT r w) where
+  return = pure
+  ContT k >>= f = ContT $ k . extend (\wa a -> runContT (f a) wa)
+
+callCC :: Comonad w => ((a -> ContT r w b) -> ContT r w a) -> ContT r w a
+callCC f = ContT $ \wc -> runContT (f (\a -> ContT $ \_ -> extract wc a)) wc
+
diff --git a/Control/Monad/Trans/Codensity.hs b/Control/Monad/Trans/Codensity.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Trans/Codensity.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE Rank2Types #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Monad.Trans.Codensity
+-- Copyright   :  (C) 2008-2011 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  non-portable (rank-2 polymorphism)
+--
+----------------------------------------------------------------------------
+module Control.Monad.Trans.Codensity
+  ( Codensity(..)
+  , lowerCodensity
+  , codensityToAdjunction
+  , adjunctionToCodensity
+  ) where
+
+import Control.Applicative
+import Control.Monad (ap)
+import Data.Functor.Adjunction
+import Data.Functor.Apply
+import Control.Monad.Trans.Class
+
+newtype Codensity m a = Codensity { runCodensity :: forall b. (a -> m b) -> m b }
+
+instance Functor (Codensity k) where
+  fmap f m = Codensity (\k -> runCodensity m (k . f))
+
+instance FunctorApply (Codensity f) where
+  (<.>) = ap
+
+instance Applicative (Codensity f) where
+  pure x = Codensity (\k -> k x)
+  (<*>) = ap
+
+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 (Codensity m) where
+  liftIO = liftCodensity . liftIO 
+-}
+
+instance MonadTrans Codensity where
+  lift m = Codensity (m >>=)
+
+lowerCodensity :: Monad m => Codensity m a -> m a
+lowerCodensity a = runCodensity a return
+
+codensityToAdjunction :: Adjunction f g => Codensity g a -> g (f a)
+codensityToAdjunction r = runCodensity r unit
+
+adjunctionToCodensity :: Adjunction f g => g (f a) -> Codensity g a
+adjunctionToCodensity f = Codensity (\a -> fmap (rightAdjunct a) f)
diff --git a/adjunctions.cabal b/adjunctions.cabal
--- a/adjunctions.cabal
+++ b/adjunctions.cabal
@@ -1,6 +1,6 @@
 name:          adjunctions
 category:      Data Structures, Adjunctions
-version:       0.3.1
+version:       0.4.0
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -22,14 +22,18 @@
     base >= 4 && < 4.4,
     contravariant >= 0.1.2 && < 0.2,
     comonad >= 0.6.2.1 && < 0.8,
+    functor-apply >= 0.7.4 && < 0.8,
     comonad-transformers >= 0.6.5 && < 0.8,
     transformers >= 0.2.0 && < 0.3
 
   exposed-modules:
-    Control.Comonad.Contra
+    Control.Comonad.Contra.Adjoint
     Control.Comonad.Trans.Adjoint
-    Control.Monad.Contra
+    Control.Comonad.Trans.Density
+    Control.Monad.Contra.Cont
+    Control.Monad.Contra.Adjoint
     Control.Monad.Trans.Adjoint
+    Control.Monad.Trans.Codensity
     Data.Functor.Adjunction
     Data.Functor.Contravariant.Adjunction
     Data.Functor.Contravariant.DualAdjunction