diff --git a/Control/Categorical/Monad.hs b/Control/Categorical/Monad.hs
--- a/Control/Categorical/Monad.hs
+++ b/Control/Categorical/Monad.hs
@@ -8,6 +8,7 @@
 import Data.Semigroup (Arg (..))
 
 import Control.Categorical.Functor
+import Control.Category.Dual
 
 infixr 1 >=>, <=<, =>=, =<=
 
@@ -79,3 +80,21 @@
 instance Comonad (->) (Arg a) where
     counit (Arg _ b) = b
     cut (Arg a b) = Arg a (Arg a b)
+
+instance Functor s t m => Functor s (->) (Kleisli t m a) where
+    map f (Kleisli φ) = Kleisli (map f . φ)
+
+instance Category s => Functor s (->) (Cokleisli s ɯ a) where
+    map f (Cokleisli φ) = Cokleisli (f . φ)
+
+instance Category s => Functor (Dual s) (NT (->)) (Kleisli s m) where
+    map (Dual f) = NT (\ (Kleisli φ) -> Kleisli (φ . f))
+
+instance Functor s t ɯ => Functor (Dual s) (NT (->)) (Cokleisli t ɯ) where
+    map (Dual f) = NT (\ (Cokleisli φ) -> Cokleisli (φ . map f))
+
+instance Monad s m => Functor (Kleisli s m) s m where
+    map = bind . kleisli
+
+instance Comonad s ɯ => Functor (Cokleisli s ɯ) s ɯ where
+    map = cobind . cokleisli
diff --git a/Data/Functor/Trans/Identity.hs b/Data/Functor/Trans/Identity.hs
new file mode 100644
--- /dev/null
+++ b/Data/Functor/Trans/Identity.hs
@@ -0,0 +1,57 @@
+module Data.Functor.Trans.Identity where
+
+import Control.Categorical.Functor
+import Control.Categorical.Monad
+
+newtype IdentityT f a = IdentityT { runIdentityT :: f a }
+
+instance Functor (NT (->)) (NT (->)) IdentityT where
+    map f = NT (\ (IdentityT x) -> IdentityT (nt f x))
+
+instance Monad (->) m => Functor (NT (Kleisli (->) m)) (NT (Kleisli (->) m)) IdentityT where
+    map f = NT (Kleisli (map IdentityT . kleisli (nt f) . runIdentityT))
+
+instance Comonad (->) ɯ => Functor (NT (Cokleisli (->) ɯ)) (NT (Cokleisli (->) ɯ)) IdentityT where
+    map f = NT (Cokleisli (IdentityT . cokleisli (nt f) . map runIdentityT))
+
+instance Monad (NT (->)) IdentityT where
+    unit = NT IdentityT
+    join = NT runIdentityT
+
+instance Comonad (NT (->)) IdentityT where
+    counit = NT runIdentityT
+    cut = NT IdentityT
+
+instance Monad (->) m => Monad (NT (Kleisli (->) m)) IdentityT where
+    unit = NT (Kleisli (unit . IdentityT))
+    join = NT (Kleisli (unit . runIdentityT))
+
+instance Comonad (->) ɯ => Monad (NT (Cokleisli (->) ɯ)) IdentityT where
+    unit = NT (Cokleisli (IdentityT . counit))
+    join = NT (Cokleisli (runIdentityT . counit))
+
+instance Comonad (->) ɯ => Comonad (NT (Cokleisli (->) ɯ)) IdentityT where
+    counit = NT (Cokleisli (runIdentityT . counit))
+    cut = NT (Cokleisli (IdentityT . counit))
+
+instance Monad (->) m => Comonad (NT (Kleisli (->) m)) IdentityT where
+    counit = NT (Kleisli (unit . runIdentityT))
+    cut = NT (Kleisli (unit . IdentityT))
+
+deriving instance Functor s (->) f => Functor s (->) (IdentityT f)
+
+instance Monad (->) f => Monad (->) (IdentityT f) where
+    unit = IdentityT . unit
+    join = IdentityT . bind runIdentityT . runIdentityT
+
+instance Comonad (->) f => Comonad (->) (IdentityT f) where
+    counit = counit . runIdentityT
+    cut = runIdentityT . cobind runIdentityT . IdentityT
+
+instance (Functor s (Kleisli (->) m) f, Endofunctor (->) m) =>
+         Functor s (Kleisli (->) m) (IdentityT f) where
+    map f = Kleisli (map IdentityT . kleisli (map f) . runIdentityT)
+
+instance (Functor s (Cokleisli (->) ɯ) f, Endofunctor (->) ɯ) =>
+         Functor s (Cokleisli (->) ɯ) (IdentityT f) where
+    map f = Cokleisli (IdentityT . cokleisli (map f) . map runIdentityT)
diff --git a/Data/Functor/Trans/Reader.hs b/Data/Functor/Trans/Reader.hs
new file mode 100644
--- /dev/null
+++ b/Data/Functor/Trans/Reader.hs
@@ -0,0 +1,37 @@
+{-# LANGUAGE RankNTypes #-}
+
+module Data.Functor.Trans.Reader where
+
+import Control.Categorical.Functor
+import Control.Categorical.Monad
+import Data.Function (flip)
+
+newtype ReaderT s r f a = ReaderT { runReaderT :: r `s` f a }
+
+instance {-# INCOHERENT #-} Functor s t f => Functor s (->) (ReaderT t r f) where
+    map f (ReaderT x) = ReaderT (map f . x)
+
+instance (Functor t (->) f, Functor (->) (->) (s r)) => Functor t (->) (ReaderT s r f) where
+    map f (ReaderT x) = ReaderT ((map f :: _ -> _) <$> x)
+
+instance Monad (->) f => Monad (->) (ReaderT (->) r f) where
+    unit = ReaderT . unit . unit
+    join (ReaderT x) = ReaderT (\ r -> (flip id r >=> flip runReaderT r) x)
+
+instance Comonad (->) ɯ => Comonad (->) (ReaderT (,) r ɯ) where
+    counit = counit . counit . runReaderT
+    cut (ReaderT (r, x)) = ReaderT (r, cobind (ReaderT . (,) r) x)
+
+instance (Functor t (->) (s r)) => Functor (NT t) (NT (->)) (ReaderT s r) where
+    map f = NT (\ (ReaderT x) -> ReaderT (nt f <$> x))
+
+instance Monad (->) (s r) => Monad (NT (->)) (ReaderT s r) where
+    unit = NT (ReaderT . unit)
+    join = NT (ReaderT . bind runReaderT . runReaderT)
+
+instance Comonad (->) (s r) => Comonad (NT (->)) (ReaderT s r) where
+    counit = NT (counit . runReaderT)
+    cut = NT (ReaderT . cobind ReaderT . runReaderT)
+
+instance Functor t (NT (->)) s => Functor t (NT (NT (->))) (ReaderT s) where
+    map f = NT (NT (\ (ReaderT x) -> ReaderT (nt (map f) x)))
diff --git a/Data/Functor/Trans/Writer.hs b/Data/Functor/Trans/Writer.hs
new file mode 100644
--- /dev/null
+++ b/Data/Functor/Trans/Writer.hs
@@ -0,0 +1,25 @@
+module Data.Functor.Trans.Writer where
+
+import Control.Categorical.Functor
+import Control.Categorical.Monad
+
+newtype WriterT p w f a = WriterT { runWriterT :: f (p w a) }
+
+instance (Functor (->) (->) f, Functor s (->) (p w)) => Functor s (->) (WriterT p w f) where
+    map f (WriterT x) = WriterT ((map f :: _ -> _) <$> x)
+
+instance (Monoid w, Monad (->) f) => Monad (->) (WriterT (,) w f) where
+    unit = WriterT . unit . unit
+    join = WriterT . bind (\ (w, WriterT y) -> map (\ (w', a) -> (w <> w', a)) y) . runWriterT
+
+instance (Comonad (->) (p w), Comonad (->) f) => Comonad (->) (WriterT p w f) where
+    counit = counit . counit . runWriterT
+    cut = WriterT . cobind (\ x -> (\ _ -> WriterT x) <$> counit x) . runWriterT
+
+instance Monad (->) f => Monad (->) (WriterT Either w f) where
+    unit = WriterT . unit . unit
+    join = WriterT . bind (\ case Left w -> unit (Left w)
+                                  Right (WriterT x) -> x) . runWriterT
+
+instance Functor (NT (->)) (NT (->)) (WriterT p w) where
+    map f = NT (\ (WriterT x) -> WriterT (nt f x))
diff --git a/category.cabal b/category.cabal
--- a/category.cabal
+++ b/category.cabal
@@ -1,5 +1,5 @@
 name:                category
-version:             0.2.1.0
+version:             0.2.2.0
 synopsis:            Categorical types and classes
 -- description:         
 license:             BSD3
@@ -19,22 +19,37 @@
                      , Control.Category.Const2
                      , Control.Category.Dual
                      , Control.Category.Groupoid
+                     , Data.Functor.Trans.Identity
+                     , Data.Functor.Trans.Reader
+                     , Data.Functor.Trans.Writer
                      , Data.Morphism.Endo
                      , Data.Morphism.Iso
   other-modules:       Prelude
   build-depends:       base >=4.10 && <5
                      , alg >=0.2 && <0.3
+                     , transformers >= 0.5 && < 0.6
   default-language:    Haskell2010
   default-extensions:  UnicodeSyntax
                      , LambdaCase
+                     , PartialTypeSignatures
                      , TypeOperators
                      , PolyKinds
                      , ConstraintKinds
                      , MultiParamTypeClasses
                      , FlexibleContexts
                      , FlexibleInstances
+                     , DerivingStrategies
+                     , StandaloneDeriving
                      , GeneralizedNewtypeDeriving
-  ghc-options:         -Wall -Wno-name-shadowing
+  ghc-options:         -Wall -Wcompat -Wredundant-constraints -Wno-name-shadowing
+                       -Wincomplete-record-updates -Wincomplete-uni-patterns
+                       -Werror=incomplete-patterns
+                       -Werror=incomplete-uni-patterns
+                       -Werror=incomplete-record-updates
+                       -Werror=missing-fields
+                       -Werror=missing-methods
+                       -Wno-partial-type-signatures
+                       -Wno-simplifiable-class-constraints
 
 source-repository head
   type: git