kan-extensions 3.6 → 3.6.2

raw patch · 6 files changed

+165/−9 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.markdown +8/−0
• kan-extensions.cabal +2/−1
• src/Data/Functor/Contravariant/Yoneda.hs +69/−0
• src/Data/Functor/Contravariant/Yoneda/Reduction.hs +5/−0
• src/Data/Functor/Yoneda.hs +42/−4
• src/Data/Functor/Yoneda/Reduction.hs +39/−4

@@ -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)`

@@ -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

@@ -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 #-}

@@ -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 #-}

@@ -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))

@@ -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