kan-extensions 0.2.2 → 0.5.0

raw patch · 5 files changed

+242/−269 lines, 5 filesdep +comonads-fddep ~adjunctionsdep ~comonad-transformersdep ~keysPVP ok

version bump matches the API change (PVP)

Dependencies added: comonads-fd

Dependency ranges changed: adjunctions, comonad-transformers, keys, representable-functors

API changes (from Hackage documentation)

Files

• Control/Comonad/Density.hs +19/−19
• Control/Monad/Codensity.hs +40/−35
• Data/Functor/Yoneda.hs +95/−115
• Data/Functor/Yoneda/Contravariant.hs +80/−93
• kan-extensions.cabal +8/−7

@@ -15,36 +15,36 @@ -- ''Formal Theory of Monads''. ---------------------------------------------------------------------------- module Control.Comonad.Density-  ( DensityT(..)-  , liftDensityT-  , densityTToAdjunction, adjunctionToDensityT+  ( Density(..)+  , liftDensity+  , densityToAdjunction, adjunctionToDensity   ) where  import Control.Comonad import Control.Comonad.Trans.Class import Data.Functor.Adjunction -data DensityT k a where-  DensityT :: (k b -> a) -> k b -> DensityT k a+data Density k a where+  Density :: (k b -> a) -> k b -> Density k a -instance Functor (DensityT f) where-  fmap f (DensityT g h) = DensityT (f . g) h+instance Functor (Density f) where+  fmap f (Density g h) = Density (f . g) h -instance Extend (DensityT f) where-  duplicate (DensityT f ws) = DensityT (DensityT f) ws+instance Extend (Density f) where+  duplicate (Density f ws) = Density (Density f) ws -instance Comonad (DensityT f) where-  extract (DensityT f a) = f a+instance Comonad (Density f) where+  extract (Density f a) = f a -instance ComonadTrans DensityT where-  lower (DensityT f c) = extend f c+instance ComonadTrans Density where+  lower (Density f c) = extend f c    -- | The natural isomorphism between a comonad w and the comonad generated by w (forwards).-liftDensityT :: Comonad w => w a -> DensityT w a-liftDensityT = DensityT extract +liftDensity :: Comonad w => w a -> Density w a+liftDensity = Density extract  -densityTToAdjunction :: Adjunction f g => DensityT f a -> f (g a)-densityTToAdjunction (DensityT f v) = fmap (leftAdjunct f) v+densityToAdjunction :: Adjunction f g => Density f a -> f (g a)+densityToAdjunction (Density f v) = fmap (leftAdjunct f) v -adjunctionToDensityT :: Adjunction f g => f (g a) -> DensityT f a-adjunctionToDensityT = DensityT counit+adjunctionToDensity :: Adjunction f g => f (g a) -> Density f a+adjunctionToDensity = Density counit

@@ -1,4 +1,4 @@-{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE Rank2Types, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-} ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Codensity@@ -11,60 +11,65 @@ -- ---------------------------------------------------------------------------- module Control.Monad.Codensity-  ( CodensityT(..)-  , lowerCodensityT-  , codensityTToAdjunction-  , adjunctionToCodensityT+  ( Codensity(..)+  , lowerCodensity+  , codensityToAdjunction+  , adjunctionToCodensity   ) where  import Control.Applicative+import Control.Monad.Reader.Class+import Control.Monad.State.Class+import Control.Monad.Free.Class import Control.Monad (ap, MonadPlus(..)) import Data.Functor.Adjunction import Data.Functor.Apply import Control.Monad.Trans.Class import Control.Monad.IO.Class -{--type Codensity = CodensityT Identity-codensity :: (forall b. (a -> b) -> b) -> Codensity a-runCodensity :: Codensity a -> (a -> b) -> a--}--newtype CodensityT m a = CodensityT { runCodensityT :: forall b. (a -> m b) -> m b }+newtype Codensity m a = Codensity { runCodensity :: forall b. (a -> m b) -> m b } -instance Functor (CodensityT k) where-  fmap f (CodensityT m) = CodensityT (\k -> m (k . f))+instance Functor (Codensity k) where+  fmap f (Codensity m) = Codensity (\k -> m (k . f)) -instance Apply (CodensityT f) where+instance Apply (Codensity f) where   (<.>) = ap -instance Applicative (CodensityT f) where-  pure x = CodensityT (\k -> k x)+instance Applicative (Codensity f) where+  pure x = Codensity (\k -> k x)   (<*>) = ap -instance Monad (CodensityT f) where-  return x = CodensityT (\k -> k x)-  m >>= k = CodensityT (\c -> runCodensityT m (\a -> runCodensityT (k a) c))+instance Monad (Codensity f) where+  return x = Codensity (\k -> k x)+  m >>= k = Codensity (\c -> runCodensity m (\a -> runCodensity (k a) c)) -instance MonadIO m => MonadIO (CodensityT m) where+instance MonadIO m => MonadIO (Codensity m) where   liftIO = lift . liftIO  -instance MonadTrans CodensityT where-  lift m = CodensityT (m >>=)+instance MonadTrans Codensity where+  lift m = Codensity (m >>=) -instance Alternative v => Alternative (CodensityT v) where-  empty                         = CodensityT (\_ -> empty)-  CodensityT m <|> CodensityT n = CodensityT (\k -> m k <|> n k)+instance Alternative v => Alternative (Codensity v) where+  empty                         = Codensity (\_ -> empty)+  Codensity m <|> Codensity n = Codensity (\k -> m k <|> n k) -instance MonadPlus v => MonadPlus (CodensityT v) where-  mzero                             = CodensityT (\_ -> mzero)-  CodensityT m `mplus` CodensityT n = CodensityT (\k -> m k `mplus` n k)+instance MonadPlus v => MonadPlus (Codensity v) where+  mzero                             = Codensity (\_ -> mzero)+  Codensity m `mplus` Codensity n = Codensity (\k -> m k `mplus` n k)  -lowerCodensityT :: Monad m => CodensityT m a -> m a-lowerCodensityT a = runCodensityT a return+lowerCodensity :: Monad m => Codensity m a -> m a+lowerCodensity a = runCodensity a return -codensityTToAdjunction :: Adjunction f g => CodensityT g a -> g (f a)-codensityTToAdjunction r = runCodensityT r unit+codensityToAdjunction :: Adjunction f g => Codensity g a -> g (f a)+codensityToAdjunction r = runCodensity r unit -adjunctionToCodensityT :: Adjunction f g => g (f a) -> CodensityT g a-adjunctionToCodensityT f = CodensityT (\a -> fmap (rightAdjunct a) f)+adjunctionToCodensity :: Adjunction f g => g (f a) -> Codensity g a+adjunctionToCodensity f = Codensity (\a -> fmap (rightAdjunct a) f)++instance MonadFree f m => MonadFree f (Codensity m) where+  wrap t = Codensity (\h -> wrap (fmap (\p -> runCodensity p h) t))++instance MonadReader r m => MonadState r (Codensity m) where+  get = Codensity (ask >>=)+  put s = Codensity (\k -> local (const s) (k ()))+

@@ -1,4 +1,4 @@-{-# LANGUAGE TypeFamilies, CPP, Rank2Types, FlexibleContexts, MultiParamTypeClasses, UndecidableInstances #-}+{-# LANGUAGE TypeFamilies, CPP, Rank2Types, FlexibleContexts, MultiParamTypeClasses, UndecidableInstances, FlexibleInstances #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Functor.Yoneda@@ -12,20 +12,16 @@ ----------------------------------------------------------------------------  module Data.Functor.Yoneda-  ( Yoneda-  , yoneda-  , runYoneda+  ( Yoneda(..)   , liftYoneda   , lowerYoneda-  , YonedaT(..)-  , liftYonedaT-  , lowerYonedaT   , maxF, minF, maxM, minM   ) where  import Control.Applicative import Control.Monad (MonadPlus(..), liftM) import Control.Monad.Fix+import Control.Monad.Free.Class import Control.Monad.Representable import Control.Monad.Trans.Class import Control.Comonad@@ -34,7 +30,6 @@ import Data.Foldable import Data.Function (on) import Data.Functor.Plus-import Data.Functor.Identity import Data.Functor.Bind import Data.Functor.Adjunction import Data.Key@@ -45,161 +40,146 @@ import Text.Read hiding (lift) import Prelude hiding (sequence, lookup) -type Yoneda = YonedaT Identity --yoneda :: (forall b. (a -> b) -> b) -> Yoneda a-yoneda f = YonedaT (Identity . f)-{-# INLINE yoneda #-}--runYoneda :: Yoneda a -> (a -> b) -> b-runYoneda (YonedaT f) = runIdentity . f-{-# INLINE runYoneda #-}--liftYoneda :: a -> Yoneda a-liftYoneda a = YonedaT (\f -> Identity (f a))-{-# INLINE liftYoneda #-}--lowerYoneda :: Yoneda a -> a-lowerYoneda m = runIdentity (runYonedaT m id)-{-# INLINE lowerYoneda #-}--newtype YonedaT f a = YonedaT { runYonedaT :: forall b. (a -> b) -> f b } +newtype Yoneda f a = Yoneda { runYoneda :: forall b. (a -> b) -> f b }  -liftYonedaT :: Functor f => f a -> YonedaT f a -liftYonedaT a = YonedaT (\f -> fmap f a)+liftYoneda :: Functor f => f a -> Yoneda f a +liftYoneda a = Yoneda (\f -> fmap f a) -lowerYonedaT :: YonedaT f a -> f a -lowerYonedaT (YonedaT f) = f id+lowerYoneda :: Yoneda f a -> f a +lowerYoneda (Yoneda f) = f id -{-# RULES "lower/lift=id" liftYonedaT . lowerYonedaT = id #-}-{-# RULES "lift/lower=id" lowerYonedaT . liftYonedaT = id #-}+{-# RULES "lower/lift=id" liftYoneda . lowerYoneda = id #-}+{-# RULES "lift/lower=id" lowerYoneda . liftYoneda = id #-} -instance Functor (YonedaT f) where-  fmap f m = YonedaT (\k -> runYonedaT m (k . f))+instance Functor (Yoneda f) where+  fmap f m = Yoneda (\k -> runYoneda m (k . f)) -type instance Key (YonedaT f) = Key f+type instance Key (Yoneda f) = Key f -instance Keyed f => Keyed (YonedaT f) where-  mapWithKey f = liftYonedaT . mapWithKey f . lowerYonedaT +instance Keyed f => Keyed (Yoneda f) where+  mapWithKey f = liftYoneda . mapWithKey f . lowerYoneda  -instance Apply f => Apply (YonedaT f) where-  YonedaT m <.> YonedaT n = YonedaT (\f -> m (f .) <.> n id)+instance Apply f => Apply (Yoneda f) where+  Yoneda m <.> Yoneda n = Yoneda (\f -> m (f .) <.> n id)   -instance Applicative f => Applicative (YonedaT f) where-  pure a = YonedaT (\f -> pure (f a))-  YonedaT m <*> YonedaT n = YonedaT (\f -> m (f .) <*> n id)+instance Applicative f => Applicative (Yoneda f) where+  pure a = Yoneda (\f -> pure (f a))+  Yoneda m <*> Yoneda n = Yoneda (\f -> m (f .) <*> n id) -instance Foldable f => Foldable (YonedaT f) where-  foldMap f = foldMap f . lowerYonedaT+instance Foldable f => Foldable (Yoneda f) where+  foldMap f = foldMap f . lowerYoneda -instance Foldable1 f => Foldable1 (YonedaT f) where-  foldMap1 f = foldMap1 f . lowerYonedaT+instance Foldable1 f => Foldable1 (Yoneda f) where+  foldMap1 f = foldMap1 f . lowerYoneda -instance FoldableWithKey f => FoldableWithKey (YonedaT f) where-  foldMapWithKey f = foldMapWithKey f . lowerYonedaT+instance FoldableWithKey f => FoldableWithKey (Yoneda f) where+  foldMapWithKey f = foldMapWithKey f . lowerYoneda -instance FoldableWithKey1 f => FoldableWithKey1 (YonedaT f) where-  foldMapWithKey1 f = foldMapWithKey1 f . lowerYonedaT+instance FoldableWithKey1 f => FoldableWithKey1 (Yoneda f) where+  foldMapWithKey1 f = foldMapWithKey1 f . lowerYoneda -instance Traversable f => Traversable (YonedaT f) where-  traverse f = fmap liftYonedaT . traverse f . lowerYonedaT+instance Traversable f => Traversable (Yoneda f) where+  traverse f = fmap liftYoneda . traverse f . lowerYoneda -instance TraversableWithKey f => TraversableWithKey (YonedaT f) where-  traverseWithKey f = fmap liftYonedaT . traverseWithKey f . lowerYonedaT+instance TraversableWithKey f => TraversableWithKey (Yoneda f) where+  traverseWithKey f = fmap liftYoneda . traverseWithKey f . lowerYoneda -instance Traversable1 f => Traversable1 (YonedaT f) where-  traverse1 f = fmap liftYonedaT . traverse1 f . lowerYonedaT+instance Traversable1 f => Traversable1 (Yoneda f) where+  traverse1 f = fmap liftYoneda . traverse1 f . lowerYoneda -instance TraversableWithKey1 f => TraversableWithKey1 (YonedaT f) where-  traverseWithKey1 f = fmap liftYonedaT . traverseWithKey1 f . lowerYonedaT+instance TraversableWithKey1 f => TraversableWithKey1 (Yoneda f) where+  traverseWithKey1 f = fmap liftYoneda . traverseWithKey1 f . lowerYoneda -instance Distributive f => Distributive (YonedaT f) where-  collect f = liftYonedaT . collect (lowerYonedaT . f)+instance Distributive f => Distributive (Yoneda f) where+  collect f = liftYoneda . collect (lowerYoneda . f) -instance Indexable f => Indexable (YonedaT f) where-  index = index . lowerYonedaT+instance Indexable f => Indexable (Yoneda f) where+  index = index . lowerYoneda -instance Lookup f => Lookup (YonedaT f) where-  lookup i = lookup i . lowerYonedaT+instance Lookup f => Lookup (Yoneda f) where+  lookup i = lookup i . lowerYoneda -instance Representable g => Representable (YonedaT g) where-  tabulate = liftYonedaT . tabulate+instance Representable g => Representable (Yoneda g) where+  tabulate = liftYoneda . tabulate -instance Adjunction f g => Adjunction (YonedaT f) (YonedaT g) where-  unit = liftYonedaT . fmap liftYonedaT . unit-  counit (YonedaT m) = counit (m lowerYonedaT)+instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g) where+  unit = liftYoneda . fmap liftYoneda . unit+  counit (Yoneda m) = counit (m lowerYoneda) --- instance Show1 f => Show1 (YonedaT f) where-instance Show (f a) => Show (YonedaT f a) where-  showsPrec d (YonedaT f) = showParen (d > 10) $-    showString "liftYonedaT " . showsPrec 11 (f id)+-- instance Show1 f => Show1 (Yoneda f) where+instance Show (f a) => Show (Yoneda f a) where+  showsPrec d (Yoneda f) = showParen (d > 10) $+    showString "liftYoneda " . showsPrec 11 (f id) --- instance Read1 f => Read1 (YonedaT f) where+-- instance Read1 f => Read1 (Yoneda f) where #ifdef __GLASGOW_HASKELL__-instance (Functor f, Read (f a)) => Read (YonedaT f a) where+instance (Functor f, Read (f a)) => Read (Yoneda f a) where   readPrec = parens $ prec 10 $ do-     Ident "liftYonedaT" <- lexP-     liftYonedaT <$> step readPrec+     Ident "liftYoneda" <- lexP+     liftYoneda <$> step readPrec #endif -instance Eq (f a) => Eq (YonedaT f a) where-  (==) = (==) `on` lowerYonedaT+instance Eq (f a) => Eq (Yoneda f a) where+  (==) = (==) `on` lowerYoneda -instance Ord (f a) => Ord (YonedaT f a) where-  compare = compare `on` lowerYonedaT+instance Ord (f a) => Ord (Yoneda f a) where+  compare = compare `on` lowerYoneda -maxF :: (Functor f, Ord (f a)) => YonedaT f a -> YonedaT f a -> YonedaT f a-YonedaT f `maxF` YonedaT g = liftYonedaT $ f id `max` g id+maxF :: (Functor f, Ord (f a)) => Yoneda f a -> Yoneda f a -> Yoneda f a+Yoneda f `maxF` Yoneda g = liftYoneda $ f id `max` g id -- {-# RULES "max/maxF" max = maxF #-} {-# INLINE maxF #-} -minF :: (Functor f, Ord (f a)) => YonedaT f a -> YonedaT f a -> YonedaT f a-YonedaT f `minF` YonedaT g = liftYonedaT $ f id `max` g id+minF :: (Functor f, Ord (f a)) => Yoneda f a -> Yoneda f a -> Yoneda f a+Yoneda f `minF` Yoneda g = liftYoneda $ f id `max` g id -- {-# RULES "min/minF" min = minF #-} {-# INLINE minF #-} -maxM :: (Monad m, Ord (m a)) => YonedaT m a -> YonedaT m a -> YonedaT m a-YonedaT f `maxM` YonedaT g = lift $ f id `max` g id+maxM :: (Monad m, Ord (m a)) => Yoneda m a -> Yoneda m a -> Yoneda m a+Yoneda f `maxM` Yoneda g = lift $ f id `max` g id -- {-# RULES "max/maxM" max = maxM #-} {-# INLINE maxM #-} -minM :: (Monad m, Ord (m a)) => YonedaT m a -> YonedaT m a -> YonedaT m a-YonedaT f `minM` YonedaT g = lift $ f id `min` g id+minM :: (Monad m, Ord (m a)) => Yoneda m a -> Yoneda m a -> Yoneda m a+Yoneda f `minM` Yoneda g = lift $ f id `min` g id -- {-# RULES "min/minM" min = minM #-} {-# INLINE minM #-} -instance Alt f => Alt (YonedaT f) where-  YonedaT f <!> YonedaT g = YonedaT (\k -> f k <!> g k)+instance Alt f => Alt (Yoneda f) where+  Yoneda f <!> Yoneda g = Yoneda (\k -> f k <!> g k) -instance Plus f => Plus (YonedaT f) where-  zero = YonedaT $ const zero+instance Plus f => Plus (Yoneda f) where+  zero = Yoneda $ const zero -instance Alternative f => Alternative (YonedaT f) where-  empty = YonedaT $ const empty-  YonedaT f <|> YonedaT g = YonedaT (\k -> f k <|> g k)+instance Alternative f => Alternative (Yoneda f) where+  empty = Yoneda $ const empty+  Yoneda f <|> Yoneda g = Yoneda (\k -> f k <|> g k) -instance Bind m => Bind (YonedaT m) where-  YonedaT m >>- k = YonedaT (\f -> m id >>- \a -> runYonedaT (k a) f)+instance Bind m => Bind (Yoneda m) where+  Yoneda m >>- k = Yoneda (\f -> m id >>- \a -> runYoneda (k a) f)   -instance Monad m => Monad (YonedaT m) where-  return a = YonedaT (\f -> return (f a))-  YonedaT m >>= k = YonedaT (\f -> m id >>= \a -> runYonedaT (k a) f)+instance Monad m => Monad (Yoneda m) where+  return a = Yoneda (\f -> return (f a))+  Yoneda m >>= k = Yoneda (\f -> m id >>= \a -> runYoneda (k a) f) -instance MonadFix m => MonadFix (YonedaT m) where-  mfix f = lift $ mfix (lowerYonedaT . f)+instance MonadFix m => MonadFix (Yoneda m) where+  mfix f = lift $ mfix (lowerYoneda . f) -instance MonadPlus m => MonadPlus (YonedaT m) where-  mzero = YonedaT (const mzero)-  YonedaT f `mplus` YonedaT g = YonedaT (\k -> f k `mplus` g k)+instance MonadPlus m => MonadPlus (Yoneda m) where+  mzero = Yoneda (const mzero)+  Yoneda f `mplus` Yoneda g = Yoneda (\k -> f k `mplus` g k) -instance MonadTrans YonedaT where-  lift a = YonedaT (\f -> liftM f a)+instance MonadTrans Yoneda where+  lift a = Yoneda (\f -> liftM f a) -instance Extend w => Extend (YonedaT w) where-  extend k (YonedaT m) = YonedaT (\f -> extend (f . k . liftYonedaT) (m id))+instance MonadFree f m => MonadFree f (Yoneda m) where+  wrap = lift . wrap . fmap lowerYoneda -instance Comonad w => Comonad (YonedaT w) where-  extract = extract . lowerYonedaT +instance Extend w => Extend (Yoneda w) where+  extend k (Yoneda m) = Yoneda (\f -> extend (f . k . liftYoneda) (m id)) -instance ComonadTrans YonedaT where-  lower = lowerYonedaT +instance Comonad w => Comonad (Yoneda w) where+  extract = extract . lowerYoneda ++instance ComonadTrans Yoneda where+  lower = lowerYoneda 

@@ -11,14 +11,10 @@ -- ---------------------------------------------------------------------------- module Data.Functor.Yoneda.Contravariant-  ( Yoneda-  , yoneda+  ( Yoneda(..)   , liftYoneda   , lowerYoneda-  , liftYonedaT-  , lowerYonedaT   , lowerM-  , YonedaT(..)   ) where  import Control.Applicative@@ -32,138 +28,129 @@ import Data.Function (on) import Data.Functor.Bind import Data.Functor.Plus-import Data.Functor.Identity import Data.Functor.Adjunction import Data.Key-import Prelude hiding (sequence)+import Prelude hiding (sequence, lookup) import Text.Read hiding (lift) -type Yoneda = YonedaT Identity- -- | The contravariant Yoneda lemma applied to a covariant functor-data YonedaT f a where-  YonedaT :: (b -> a) -> f b -> YonedaT f a--yoneda :: (b -> a) -> b -> Yoneda a-yoneda f = YonedaT f . Identity--liftYoneda :: a -> Yoneda a -liftYoneda = YonedaT id . Identity--lowerYoneda :: Yoneda a -> a-lowerYoneda (YonedaT f (Identity a)) = f a+data Yoneda f a where+  Yoneda :: (b -> a) -> f b -> Yoneda f a -liftYonedaT :: f a -> YonedaT f a -liftYonedaT = YonedaT id+liftYoneda :: f a -> Yoneda f a +liftYoneda = Yoneda id -lowerYonedaT :: Functor f => YonedaT f a -> f a-lowerYonedaT (YonedaT f m) = fmap f m+lowerYoneda :: Functor f => Yoneda f a -> f a+lowerYoneda (Yoneda f m) = fmap f m -lowerM :: Monad f => YonedaT f a -> f a -lowerM (YonedaT f m) = liftM f m+lowerM :: Monad f => Yoneda f a -> f a +lowerM (Yoneda f m) = liftM f m -instance Functor (YonedaT f) where-  fmap f (YonedaT g v) = YonedaT (f . g) v+instance Functor (Yoneda f) where+  fmap f (Yoneda g v) = Yoneda (f . g) v -type instance Key (YonedaT f) = Key f+type instance Key (Yoneda f) = Key f -instance Keyed f => Keyed (YonedaT f) where-  mapWithKey f (YonedaT k a) = YonedaT id $ mapWithKey (\x -> f x . k) a+instance Keyed f => Keyed (Yoneda f) where+  mapWithKey f (Yoneda k a) = Yoneda id $ mapWithKey (\x -> f x . k) a -instance Apply f => Apply (YonedaT f) where-  m <.> n = liftYonedaT $ lowerYonedaT m <.> lowerYonedaT n+instance Apply f => Apply (Yoneda f) where+  m <.> n = liftYoneda $ lowerYoneda m <.> lowerYoneda n -instance Applicative f => Applicative (YonedaT f) where-  pure = liftYonedaT . pure-  m <*> n = liftYonedaT $ lowerYonedaT m <*> lowerYonedaT n+instance Applicative f => Applicative (Yoneda f) where+  pure = liftYoneda . pure+  m <*> n = liftYoneda $ lowerYoneda m <*> lowerYoneda n -instance Alternative f => Alternative (YonedaT f) where-  empty = liftYonedaT empty -  m <|> n = liftYonedaT $ lowerYonedaT m <|> lowerYonedaT n+instance Alternative f => Alternative (Yoneda f) where+  empty = liftYoneda empty +  m <|> n = liftYoneda $ lowerYoneda m <|> lowerYoneda n -instance Alt f => Alt (YonedaT f) where-  m <!> n = liftYonedaT $ lowerYonedaT m <!> lowerYonedaT n+instance Alt f => Alt (Yoneda f) where+  m <!> n = liftYoneda $ lowerYoneda m <!> lowerYoneda n -instance Plus f => Plus (YonedaT f) where-  zero = liftYonedaT zero+instance Plus f => Plus (Yoneda f) where+  zero = liftYoneda zero -instance Bind m => Bind (YonedaT m) where-  YonedaT f v >>- k = liftYonedaT (v >>- lowerYonedaT . k . f)+instance Bind m => Bind (Yoneda m) where+  Yoneda f v >>- k = liftYoneda (v >>- lowerYoneda . k . f) -instance Monad m => Monad (YonedaT m) where-  return = YonedaT id . return-  YonedaT f v >>= k = lift (v >>= lowerM . k . f)+instance Monad m => Monad (Yoneda m) where+  return = Yoneda id . return+  Yoneda f v >>= k = lift (v >>= lowerM . k . f) -instance MonadTrans YonedaT where-  lift = YonedaT id+instance MonadTrans Yoneda where+  lift = Yoneda id -instance MonadFix f => MonadFix (YonedaT f) where+instance MonadFix f => MonadFix (Yoneda f) where   mfix f = lift $ mfix (lowerM . f) -instance MonadPlus f => MonadPlus (YonedaT f) where+instance MonadPlus f => MonadPlus (Yoneda f) where   mzero = lift mzero   m `mplus` n = lift $ lowerM m `mplus` lowerM n -instance (Functor f, Indexable f) => Indexable (YonedaT f) where-  index = index . lowerYonedaT+instance (Functor f, Lookup f) => Lookup (Yoneda f) where+  lookup k f = lookup k (lowerYoneda f) -instance Representable f => Representable (YonedaT f) where-  tabulate = liftYonedaT . tabulate+instance (Functor f, Indexable f) => Indexable (Yoneda f) where+  index = index . lowerYoneda -instance Extend w => Extend (YonedaT w) where-  extend k (YonedaT f v) = YonedaT id $ extend (k . YonedaT f) v+instance Representable f => Representable (Yoneda f) where+  tabulate = liftYoneda . tabulate -instance Comonad w => Comonad (YonedaT w) where-  extract (YonedaT f v) = f (extract v)+instance Extend w => Extend (Yoneda w) where+  extend k (Yoneda f v) = Yoneda id $ extend (k . Yoneda f) v -instance ComonadTrans YonedaT where-  lower (YonedaT f a) = fmap f a+instance Comonad w => Comonad (Yoneda w) where+  extract (Yoneda f v) = f (extract v) -instance Foldable f => Foldable (YonedaT f) where-  foldMap f (YonedaT k a) = foldMap (f . k) a+instance ComonadTrans Yoneda where+  lower (Yoneda f a) = fmap f a -instance FoldableWithKey f => FoldableWithKey (YonedaT f) where-  foldMapWithKey f (YonedaT k a) = foldMapWithKey (\x -> f x . k) a+instance Foldable f => Foldable (Yoneda f) where+  foldMap f (Yoneda k a) = foldMap (f . k) a -instance Foldable1 f => Foldable1 (YonedaT f) where-  foldMap1 f (YonedaT k a) = foldMap1 (f . k) a+instance FoldableWithKey f => FoldableWithKey (Yoneda f) where+  foldMapWithKey f (Yoneda k a) = foldMapWithKey (\x -> f x . k) a -instance FoldableWithKey1 f => FoldableWithKey1 (YonedaT f) where-  foldMapWithKey1 f (YonedaT k a) = foldMapWithKey1 (\x -> f x . k) a+instance Foldable1 f => Foldable1 (Yoneda f) where+  foldMap1 f (Yoneda k a) = foldMap1 (f . k) a -instance Traversable f => Traversable (YonedaT f) where-  traverse f (YonedaT k a) = YonedaT id <$> traverse (f . k) a+instance FoldableWithKey1 f => FoldableWithKey1 (Yoneda f) where+  foldMapWithKey1 f (Yoneda k a) = foldMapWithKey1 (\x -> f x . k) a -instance Traversable1 f => Traversable1 (YonedaT f) where-  traverse1 f (YonedaT k a) = YonedaT id <$> traverse1 (f . k) a+instance Traversable f => Traversable (Yoneda f) where+  traverse f (Yoneda k a) = Yoneda id <$> traverse (f . k) a -instance TraversableWithKey f => TraversableWithKey (YonedaT f) where-  traverseWithKey f (YonedaT k a) = YonedaT id <$> traverseWithKey (\x -> f x . k) a+instance Traversable1 f => Traversable1 (Yoneda f) where+  traverse1 f (Yoneda k a) = Yoneda id <$> traverse1 (f . k) a -instance TraversableWithKey1 f => TraversableWithKey1 (YonedaT f) where-  traverseWithKey1 f (YonedaT k a) = YonedaT id <$> traverseWithKey1 (\x -> f x . k) a+instance TraversableWithKey f => TraversableWithKey (Yoneda f) where+  traverseWithKey f (Yoneda k a) = Yoneda id <$> traverseWithKey (\x -> f x . k) a -instance Distributive f => Distributive (YonedaT f) where-  collect f = liftYonedaT . collect (lowerYonedaT . f)+instance TraversableWithKey1 f => TraversableWithKey1 (Yoneda f) where+  traverseWithKey1 f (Yoneda k a) = Yoneda id <$> traverseWithKey1 (\x -> f x . k) a -instance (Functor f, Show (f a)) => Show (YonedaT f a) where-  showsPrec d (YonedaT f a) = showParen (d > 10) $-    showString "liftYonedaT " . showsPrec 11 (fmap f a)+instance Distributive f => Distributive (Yoneda f) where+  collect f = liftYoneda . collect (lowerYoneda . f) +instance (Functor f, Show (f a)) => Show (Yoneda f a) where+  showsPrec d (Yoneda f a) = showParen (d > 10) $+    showString "liftYoneda " . showsPrec 11 (fmap f a)+ #ifdef __GLASGOW_HASKELL__-instance (Functor f, Read (f a)) => Read (YonedaT f a) where+instance (Functor f, Read (f a)) => Read (Yoneda f a) where   readPrec = parens $ prec 10 $ do-    Ident "liftYonedaT" <- lexP-    liftYonedaT <$> step readPrec+    Ident "liftYoneda" <- lexP+    liftYoneda <$> step readPrec #endif -instance (Functor f, Eq (f a)) => Eq (YonedaT f a) where-  (==) = (==) `on` lowerYonedaT+instance (Functor f, Eq (f a)) => Eq (Yoneda f a) where+  (==) = (==) `on` lowerYoneda -instance (Functor f, Ord (f a)) => Ord (YonedaT f a) where-  compare = compare `on` lowerYonedaT+instance (Functor f, Ord (f a)) => Ord (Yoneda f a) where+  compare = compare `on` lowerYoneda -instance Adjunction f g => Adjunction (YonedaT f) (YonedaT g) where-  unit = liftYonedaT . fmap liftYonedaT . unit-  counit = counit . fmap lowerYonedaT . lowerYonedaT+instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g) where+  unit = liftYoneda . fmap liftYoneda . unit+  counit = counit . fmap lowerYoneda . lowerYoneda 

@@ -1,13 +1,13 @@ name:          kan-extensions category:      Data Structures, Monads, Comonads, Functors-version:       0.2.2+version:       0.5.0 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE author:        Edward A. Kmett maintainer:    Edward A. Kmett <ekmett@gmail.com> stability:     provisional-homepage:      http://github.com/ekmett/adjunctions/+homepage:      http://github.com/ekmett/kan-extensions/ copyright:     Copyright (C) 2011 Edward A. Kmett synopsis:      Kan extensions, the Yoneda lemma, and (co)density (co)monads description:   Kan extensions, the Yoneda lemma, and (co)density (co)monads@@ -15,21 +15,22 @@  source-repository head   type: git-  location: git://github.com/ekmett/adjunctions.git+  location: git://github.com/ekmett/kan-extensions.git  library   build-depends: -    adjunctions >= 0.9.3 && < 0.10,+    adjunctions >= 1.0.0 && < 1.0.1,     array >= 0.3.0.2 && < 0.4,     base >= 4 && < 4.4,     comonad >= 1.1 && < 1.2,-    comonad-transformers >= 1.6.3 && < 1.7,+    comonads-fd >= 1.7 && < 1.8,+    comonad-transformers >= 1.7 && < 1.8,     containers >= 0.4 && < 0.5,     contravariant >= 0.1.2 && < 0.2,     distributive >= 0.2 && < 0.3,-    keys >= 0.2.6 && < 0.3,+    keys >= 0.3 && < 0.4,     mtl >= 2.0.1.0 && < 2.1,-    representable-functors >= 0.4.3 && < 0.5,+    representable-functors >= 0.5 && < 0.6,     semigroups >= 0.5 && < 0.6,     semigroupoids >= 1.2.2 && < 1.3.0,     transformers >= 0.2.0 && < 0.3