diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,11 @@
+3.6.2
+-----
+* Added `Data.Functor.Contravariant.Yoneda` to complete the set of Yoneda embeddings/reductions.
+
+3.6.1
+-----
+* Added several missing isomorphisms
+
 3.6
 ---
 * `instance Monad m => MonadSpec (Yoneda m)`
diff --git a/kan-extensions.cabal b/kan-extensions.cabal
--- a/kan-extensions.cabal
+++ b/kan-extensions.cabal
@@ -1,6 +1,6 @@
 name:          kan-extensions
 category:      Data Structures, Monads, Comonads, Functors
-version:       3.6
+version:       3.6.2
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -62,6 +62,7 @@
     Control.Comonad.Density
     Control.Monad.Co
     Control.Monad.Codensity
+    Data.Functor.Contravariant.Yoneda
     Data.Functor.Contravariant.Yoneda.Reduction
     Data.Functor.Kan.Lan
     Data.Functor.Kan.Lift
diff --git a/src/Data/Functor/Contravariant/Yoneda.hs b/src/Data/Functor/Contravariant/Yoneda.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Functor/Contravariant/Yoneda.hs
@@ -0,0 +1,69 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE UndecidableInstances #-}
+#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702
+{-# LANGUAGE Trustworthy #-}
+#endif
+-----------------------------------------------------------------------------
+-- |
+-- Copyright   :  (C) 2013 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+--
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  GADTs, TFs, MPTCs
+--
+----------------------------------------------------------------------------
+module Data.Functor.Contravariant.Yoneda
+  ( Yoneda(..)
+  , liftYoneda, lowerYoneda
+  ) where
+
+import Data.Functor.Contravariant
+import Data.Functor.Contravariant.Adjunction
+import Data.Functor.Contravariant.Representable
+
+-- | Yoneda embedding for a presheaf
+newtype Yoneda f a = Yoneda { runYoneda :: forall r. (r -> a) -> f r }
+
+-- |
+--
+-- @
+-- 'liftYoneda' . 'lowerYoneda' ≡ 'id'
+-- 'lowerYoneda' . 'liftYoneda' ≡ 'id'
+-- @
+
+liftYoneda :: Contravariant f => f a -> Yoneda f a
+liftYoneda fa = Yoneda $ \ra -> contramap ra fa
+{-# INLINE liftYoneda #-}
+
+lowerYoneda :: Yoneda f a -> f a
+lowerYoneda f = runYoneda f id
+{-# INLINE lowerYoneda #-}
+
+instance Contravariant (Yoneda f) where
+  contramap ab (Yoneda m) = Yoneda (m . fmap ab)
+  {-# INLINE contramap #-}
+
+type instance Value (Yoneda f) = Value f
+
+instance Valued f => Valued (Yoneda f) where
+  contramapWithValue beav = liftYoneda . contramapWithValue beav . lowerYoneda
+  {-# INLINE contramapWithValue #-}
+
+instance Coindexed f => Coindexed (Yoneda f) where
+  coindex m a = coindex (lowerYoneda m) a
+  {-# INLINE coindex #-}
+
+instance Representable f => Representable (Yoneda f) where
+  contrarep = liftYoneda . contrarep
+  {-# INLINE contrarep #-}
+
+instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g) where
+  leftAdjunct f = liftYoneda . leftAdjunct (lowerYoneda . f)
+  {-# INLINE leftAdjunct #-}
+  rightAdjunct f = liftYoneda . rightAdjunct (lowerYoneda . f)
+  {-# INLINE rightAdjunct #-}
diff --git a/src/Data/Functor/Contravariant/Yoneda/Reduction.hs b/src/Data/Functor/Contravariant/Yoneda/Reduction.hs
--- a/src/Data/Functor/Contravariant/Yoneda/Reduction.hs
+++ b/src/Data/Functor/Contravariant/Yoneda/Reduction.hs
@@ -60,6 +60,11 @@
   {-# INLINE rightAdjunct #-}
 
 -- | Yoneda "expansion" of a presheaf
+--
+-- @
+-- 'liftYoneda' . 'lowerYoneda' ≡ 'id'
+-- 'lowerYoneda' . 'liftYoneda' ≡ 'id'
+-- @
 liftYoneda :: f a -> Yoneda f a
 liftYoneda = Yoneda id
 {-# INLINE liftYoneda #-}
diff --git a/src/Data/Functor/Yoneda.hs b/src/Data/Functor/Yoneda.hs
--- a/src/Data/Functor/Yoneda.hs
+++ b/src/Data/Functor/Yoneda.hs
@@ -33,9 +33,12 @@
 
 module Data.Functor.Yoneda
   ( Yoneda(..)
-  , liftYoneda
-  , lowerYoneda
+  , liftYoneda, lowerYoneda
   , maxF, minF, maxM, minM
+  -- * as a right Kan extension
+  , yonedaToRan, ranToYoneda
+  -- * as a right Kan lift
+  , yonedaToRift, riftToYoneda
   ) where
 
 import Control.Applicative
@@ -50,10 +53,13 @@
 import Data.Distributive
 import Data.Foldable
 import Data.Function (on)
-import Data.Functor.Plus
+import Data.Functor.Adjunction
 import Data.Functor.Bind
 import Data.Functor.Extend
-import Data.Functor.Adjunction
+import Data.Functor.Identity
+import Data.Functor.Kan.Ran
+import Data.Functor.Kan.Rift
+import Data.Functor.Plus
 import Data.Functor.Representable
 import Data.Key
 import Data.Semigroup.Foldable
@@ -80,6 +86,38 @@
 
 {-# RULES "lower/lift=id" liftYoneda . lowerYoneda = id #-}
 {-# RULES "lift/lower=id" lowerYoneda . liftYoneda = id #-}
+
+-- | @Yoneda f@ is the right Kan extension of @f@ along the 'Identity' functor.
+--
+-- @
+-- 'yonedaToRan' . 'ranToYoneda' ≡ 'id'
+-- 'ranToYoneda' . 'yonedaToRan' ≡ 'id'
+-- @
+yonedaToRan :: Yoneda f a -> Ran Identity f a
+yonedaToRan (Yoneda m) = Ran (m . fmap runIdentity)
+
+ranToYoneda :: Ran Identity f a -> Yoneda f a
+ranToYoneda (Ran m) = Yoneda (m . fmap Identity)
+
+{-# RULES "yonedaToRan/ranToYoneda=id" yonedaToRan . ranToYoneda = id #-}
+{-# RULES "ranToYoneda/yonedaToRan=id" ranToYoneda . yonedaToRan = id #-}
+
+-- | @Yoneda f@ is the right Kan lift of @f@ along the 'Identity' functor.
+--
+-- @
+-- 'yonedaToRift' . 'riftToYoneda' ≡ 'id'
+-- 'riftToYoneda' . 'yonedaToRift' ≡ 'id'
+-- @
+yonedaToRift :: Yoneda f a -> Rift Identity f a
+yonedaToRift m = Rift (runYoneda m . runIdentity)
+{-# INLINE yonedaToRift #-}
+
+riftToYoneda :: Rift Identity f a -> Yoneda f a
+riftToYoneda m = Yoneda (runRift m . Identity)
+{-# INLINE riftToYoneda #-}
+
+{-# RULES "yonedaToRift/riftToYoneda=id" yonedaToRift . riftToYoneda = id #-}
+{-# RULES "riftToYoneda/yonedaToRift=id" riftToYoneda . yonedaToRift = id #-}
 
 instance Functor (Yoneda f) where
   fmap f m = Yoneda (\k -> runYoneda m (k . f))
diff --git a/src/Data/Functor/Yoneda/Reduction.hs b/src/Data/Functor/Yoneda/Reduction.hs
--- a/src/Data/Functor/Yoneda/Reduction.hs
+++ b/src/Data/Functor/Yoneda/Reduction.hs
@@ -26,9 +26,11 @@
 ----------------------------------------------------------------------------
 module Data.Functor.Yoneda.Reduction
   ( Yoneda(..)
-  , liftYoneda
-  , lowerYoneda
-  , lowerM
+  , liftYoneda, lowerYoneda, lowerM
+  -- * as a Left Kan extension
+  , yonedaToLan, lanToYoneda
+  -- * as a Left Kan lift
+  , yonedaToLift, liftToYoneda
   ) where
 
 import Control.Applicative
@@ -39,10 +41,13 @@
 import Control.Comonad.Trans.Class
 import Data.Distributive
 import Data.Function (on)
+import Data.Functor.Adjunction
 import Data.Functor.Bind
 import Data.Functor.Extend
+import Data.Functor.Identity
+import Data.Functor.Kan.Lan
+import Data.Functor.Kan.Lift
 import Data.Functor.Plus
-import Data.Functor.Adjunction
 import Data.Functor.Representable
 import Data.Key
 import Data.Foldable
@@ -55,6 +60,36 @@
 -- | A form suitable for Yoneda reduction
 data Yoneda f a where
   Yoneda :: (b -> a) -> f b -> Yoneda f a
+
+-- | @Yoneda f@ is the left Kan extension of @f@ along the 'Identity' functor.
+--
+-- @
+-- 'yonedaToLan' . 'lanToYoneda' ≡ 'id'
+-- 'lanToYoneda' . 'yonedaToLan' ≡ 'id'
+-- @
+yonedaToLan :: Yoneda f a -> Lan Identity f a
+yonedaToLan (Yoneda ba fb) = Lan (ba . runIdentity) fb
+
+lanToYoneda :: Lan Identity f a -> Yoneda f a
+lanToYoneda (Lan iba fb) = Yoneda (iba . Identity) fb
+
+{-# RULES "yonedaToLan/lanToYoneda=id" yonedaToLan . lanToYoneda = id #-}
+{-# RULES "lanToYoneda/yonedaToLan=id" lanToYoneda . yonedaToLan = id #-}
+
+-- | @Yoneda f@ is the left Kan lift of @f@ along the 'Identity' functor.
+--
+-- @
+-- 'yonedaToLift' . 'liftToYoneda' ≡ 'id'
+-- 'liftToYoneda' . 'yonedaToLift' ≡ 'id'
+-- @
+yonedaToLift :: Yoneda f a -> Lift Identity f a
+yonedaToLift (Yoneda ba fb) = Lift $ \ f2iz -> ba <$> runIdentity (f2iz fb)
+
+liftToYoneda :: Functor f => Lift Identity f a -> Yoneda f a
+liftToYoneda (Lift m) = Yoneda id (m Identity)
+
+{-# RULES "yonedaToLift/liftToYoneda=id" yonedaToLift . liftToYoneda = id #-}
+{-# RULES "liftToYoneda/yonedaToLift=id" liftToYoneda . yonedaToLift = id #-}
 
 instance Functor (Yoneda f) where
   fmap f (Yoneda g v) = Yoneda (f . g) v