diff --git a/Control/Comonad/Density.hs b/Control/Comonad/Density.hs
new file mode 100644
--- /dev/null
+++ b/Control/Comonad/Density.hs
@@ -0,0 +1,24 @@
+{-# LANGUAGE ExistentialQuantification #-}
+
+module Control.Comonad.Density where
+
+import Control.Comonad
+import Control.Comonad.Trans.Class
+
+data Density f a = ∀ b . Density (f b -> a) (f b)
+
+deriving instance Functor (Density f)
+
+instance Applicative f => Applicative (Density f) where
+    pure a = Density (pure a) (pure ())
+    Density f x <*> Density g y = pure ((f x) (g y))
+
+instance Comonad (Density f) where
+    copure (Density f x) = f x
+    cut ɯ@(Density _ x) = Density (pure ɯ) x
+
+instance ComonadTrans Density where
+    colift (Density f x) = f <<= x
+
+lift :: Comonad ɯ => ɯ a -> Density ɯ a
+lift = Density copure
diff --git a/Control/Monad/Codensity.hs b/Control/Monad/Codensity.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Codensity.hs
@@ -0,0 +1,34 @@
+{-# LANGUAGE RankNTypes #-}
+
+module Control.Monad.Codensity where
+
+import Prelude hiding (fail)
+import Control.Applicative
+import Control.Monad hiding (fail)
+import Control.Monad.Fail
+import Control.Monad.Trans.Class
+
+newtype Codensity m a = Codensity { codensity :: ∀ b . (a -> m b) -> m b }
+
+deriving instance Functor (Codensity m)
+
+instance Applicative (Codensity p) where
+    pure x = Codensity ($ x)
+    Codensity x <*> Codensity y = Codensity (\ g -> x (\ f -> y (g . f)))
+
+instance Monad (Codensity m) where
+    Codensity x >>= f = Codensity (x . flip (codensity . f))
+
+instance MonadFail f => MonadFail (Codensity f) where
+    fail xs = Codensity (\ _ -> fail xs)
+
+instance Alternative p => Alternative (Codensity p) where
+    empty = Codensity (pure empty)
+    Codensity x <|> Codensity y = Codensity (liftA2 (<|>) x y)
+
+instance Alternative p => MonadPlus (Codensity p)
+
+instance MonadTrans Codensity where lift xm = Codensity (xm >>=)
+
+unlift :: Applicative p => Codensity p a -> p a
+unlift = flip codensity pure
diff --git a/Control/Monad/Morph.hs b/Control/Monad/Morph.hs
--- a/Control/Monad/Morph.hs
+++ b/Control/Monad/Morph.hs
@@ -3,13 +3,16 @@
 module Control.Monad.Morph where
 
 import Control.Monad
+import Control.Monad.Trans.Accum
 import Control.Monad.Trans.Class
 import Control.Monad.Trans.Except
 import Control.Monad.Trans.Identity
 import Control.Monad.Trans.Maybe
 import Control.Monad.Trans.Reader
-import Control.Monad.Trans.State
-import Control.Monad.Trans.Writer
+import Control.Monad.Trans.State.Lazy as L
+import Control.Monad.Trans.State.Strict as S
+import Control.Monad.Trans.Writer.Lazy as L
+import Control.Monad.Trans.Writer.Strict as S
 import Data.Functor.Compose
 import Data.Functor.Product
 import Data.Functor.Sum
@@ -31,16 +34,21 @@
     mmap _ (InL x) = InL x
     mmap f (InR y) = InR (f y)
 
-instance MFunctor (ExceptT e) where mmap = mapExceptT
-instance MFunctor IdentityT   where mmap = mapIdentityT
-instance MFunctor MaybeT      where mmap = mapMaybeT
-instance MFunctor (ReaderT r) where mmap = mapReaderT
-instance MFunctor (StateT  s) where mmap = mapStateT
-instance MFunctor (WriterT w) where mmap = mapWriterT
+instance MFunctor (ExceptT e)   where mmap = mapExceptT
+instance MFunctor IdentityT     where mmap = mapIdentityT
+instance MFunctor MaybeT        where mmap = mapMaybeT
+instance MFunctor (ReaderT r)   where mmap = mapReaderT
+instance MFunctor (L.StateT s)  where mmap = L.mapStateT
+instance MFunctor (S.StateT s)  where mmap = S.mapStateT
+instance MFunctor (L.WriterT w) where mmap = L.mapWriterT
+instance MFunctor (S.WriterT w) where mmap = S.mapWriterT
+instance MFunctor (AccumT c)    where mmap = mapAccumT
 
 instance MMonad (ExceptT e) where mjoin (ExceptT   (ExceptT   x)) = ExceptT (join <$> x)
 instance MMonad IdentityT   where mjoin (IdentityT (IdentityT x)) = IdentityT x
 instance MMonad MaybeT      where mjoin (MaybeT    (MaybeT    x)) = MaybeT (join <$> x)
 instance MMonad (ReaderT r) where mjoin (ReaderT f) = ReaderT (join (runReaderT . f))
-instance Monoid w => MMonad (WriterT w) where
-    mjoin (WriterT (WriterT x)) = WriterT ((\ ((a, u), v) -> (a, u <> v)) <$> x)
+instance Monoid w => MMonad (L.WriterT w) where
+    mjoin (L.WriterT (L.WriterT x)) = L.WriterT ((\ ((a, u), v) -> (a, u <> v)) <$> x)
+instance Monoid w => MMonad (S.WriterT w) where
+    mjoin (S.WriterT (S.WriterT x)) = S.WriterT ((\ ((a, u), v) -> (a, u <> v)) <$> x)
diff --git a/hs-functors.cabal b/hs-functors.cabal
--- a/hs-functors.cabal
+++ b/hs-functors.cabal
@@ -1,5 +1,5 @@
 name:                hs-functors
-version:             0.1.2.0
+version:             0.1.3.0
 synopsis:            Functors from products of Haskell and its dual to Haskell
 -- description:         
 license:             BSD3
@@ -10,13 +10,15 @@
 category:            Math
 build-type:          Simple
 cabal-version:       >=1.10
-tested-with:         GHC ==8.0.2
-                   , GHC ==8.2.2
+tested-with:         GHC ==8.2.2
+                   , GHC ==8.4.2
 
 library
   exposed-modules:     Control.Comonad
                      , Control.Comonad.Cofree
+                     , Control.Comonad.Density
                      , Control.Comonad.Trans.Class
+                     , Control.Monad.Codensity
                      , Control.Monad.Free
                      , Control.Monad.Morph
                      , Control.Monad.Trans.Compose