diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/).
 
+## 0.3.1.2 – 2020–05–18
+### Added
+- `HFunctor` instances
+
 ## 0.3.1.1 – 2020–05–18
 ### Changed
 - Turned on StrictData
diff --git a/src/Yaya/Functor.hs b/src/Yaya/Functor.hs
--- a/src/Yaya/Functor.hs
+++ b/src/Yaya/Functor.hs
@@ -2,7 +2,21 @@
 --   functor type classes between various categories.
 module Yaya.Functor where
 
+import Control.Applicative.Backwards (Backwards (..))
+import Control.Applicative.Lift (Lift (..))
+import qualified Control.Monad.Trans.Except        as Ex
+import qualified Control.Monad.Trans.Identity      as I
+import qualified Control.Monad.Trans.Maybe         as M
+import qualified Control.Monad.Trans.Reader        as R
+import qualified Control.Monad.Trans.RWS.Lazy      as RWS
+import qualified Control.Monad.Trans.RWS.Strict    as RWS'
+import qualified Control.Monad.Trans.State.Lazy    as S
+import qualified Control.Monad.Trans.State.Strict  as S'
+import qualified Control.Monad.Trans.Writer.Lazy   as W'
+import qualified Control.Monad.Trans.Writer.Strict as W
 import Data.Bifunctor
+import Data.Functor.Compose (Compose (..))
+import Data.Functor.Product (Product (..))
 
 -- | A functor from the category of endofunctors to *Hask*. The @D@ is meant to
 --   be a mnemonic for “down”, as we’re “lowering” from endofunctors to types.
@@ -18,5 +32,52 @@
 firstMap f = dmap (first f)
 
 -- | An endofunctor in the category of endofunctors.
+--
+--  __NB__: This is similar to `Control.Monad.Morph.MFunctor` /
+--         `Control.Monad.Morph.hoist` from mmorph, but without the `Monad`
+--          constraint on `f`.
 class HFunctor (h :: (* -> *) -> * -> *) where
   hmap :: (forall x. f x -> g x) -> h f a -> h g a
+
+instance HFunctor (Ex.ExceptT e) where
+    hmap nat m = Ex.ExceptT (nat (Ex.runExceptT m))
+
+instance HFunctor I.IdentityT where
+    hmap nat m = I.IdentityT (nat (I.runIdentityT m))
+
+instance HFunctor M.MaybeT where
+    hmap nat m = M.MaybeT (nat (M.runMaybeT m))
+
+instance HFunctor (R.ReaderT r) where
+    hmap nat m = R.ReaderT (\i -> nat (R.runReaderT m i))
+
+instance HFunctor (RWS.RWST r w s) where
+    hmap nat m = RWS.RWST (\r s -> nat (RWS.runRWST m r s))
+
+instance HFunctor (RWS'.RWST r w s) where
+    hmap nat m = RWS'.RWST (\r s -> nat (RWS'.runRWST m r s))
+
+instance HFunctor (S.StateT s) where
+    hmap nat m = S.StateT (\s -> nat (S.runStateT m s))
+
+instance HFunctor (S'.StateT s) where
+    hmap nat m = S'.StateT (\s -> nat (S'.runStateT m s))
+
+instance HFunctor (W.WriterT w) where
+    hmap nat m = W.WriterT (nat (W.runWriterT m))
+
+instance HFunctor (W'.WriterT w) where
+    hmap nat m = W'.WriterT (nat (W'.runWriterT m))
+
+instance Functor f => HFunctor (Compose f) where
+    hmap nat (Compose f) = Compose (fmap nat f)
+
+instance HFunctor (Product f) where
+    hmap nat (Pair f g) = Pair f (nat g)
+
+instance HFunctor Backwards where
+    hmap nat (Backwards f) = Backwards (nat f)
+
+instance HFunctor Lift where
+    hmap _   (Pure a)  = Pure a
+    hmap nat (Other f) = Other (nat f)
diff --git a/yaya.cabal b/yaya.cabal
--- a/yaya.cabal
+++ b/yaya.cabal
@@ -1,5 +1,5 @@
 name:                yaya
-version:             0.3.1.1
+version:             0.3.1.2
 synopsis:            Total recursion schemes.
 description:         Recursion schemes allow you to separate recursion from your
                      business logic – making your own operations simpler, more