adjunctions 0.3.1 → 0.4.0

raw patch · 8 files changed

+265/−99 lines, 8 filesdep +functor-applyPVP ok

version bump matches the API change (PVP)

Dependencies added: functor-apply

API changes (from Hackage documentation)

Files

• Control/Comonad/Contra.hs +0/−46
• Control/Comonad/Contra/Adjoint.hs +46/−0
• Control/Comonad/Trans/Density.hs +48/−0
• Control/Monad/Contra.hs +0/−50
• Control/Monad/Contra/Adjoint.hs +51/−0
• Control/Monad/Contra/Cont.hs +56/−0
• Control/Monad/Trans/Codensity.hs +57/−0
• adjunctions.cabal +7/−3

@@ -1,46 +0,0 @@-{-# LANGUAGE MultiParamTypeClasses #-}--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Contra--- Copyright   :  (C) 2011 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  MPTCs, fundeps------ Use a contravariant dual adjunction from Hask^op to build a 'Monad' to --- 'Comonad' transformer.-------------------------------------------------------------------------------module Control.Comonad.Contra-  ( Contra-  , runContra-  , contra-  , ContraT(..)-  ) where--import Prelude hiding (sequence)-import Control.Comonad-import Control.Monad (liftM)-import Data.Functor.Identity-import Data.Functor.Contravariant-import Data.Functor.Contravariant.DualAdjunction--type Contra f g = ContraT f g Identity--newtype ContraT f g m a = ContraT { runContraT :: f (m (g a)) }--contra :: Contravariant f => f (g a) -> Contra f g a-contra = ContraT . contramap runIdentity--runContra :: Contravariant f => Contra f g a -> f (g a)-runContra = contramap Identity . runContraT--instance (Contravariant f, Contravariant g, Monad m) => Functor (ContraT f g m) where-  fmap f (ContraT g) = ContraT $ contramap (liftM (contramap f)) g-  -instance (DualAdjunction f g, Monad m) => Comonad (ContraT f g m) where-  extract = rightAdjunctOp return . runContraT-  extend f = ContraT . contramap (>>= leftAdjunctOp (f . ContraT)) . runContraT-

@@ -0,0 +1,46 @@+{-# LANGUAGE MultiParamTypeClasses #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Contra.Adjoint+-- Copyright   :  (C) 2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  MPTCs+--+-- Use a contravariant dual adjunction from Hask^op to build a 'Monad' to +-- 'Comonad' transformer.+----------------------------------------------------------------------------++module Control.Comonad.Contra.Adjoint+  ( Adjoint+  , runAdjoint+  , adjoint+  , AdjointT(..)+  ) where++import Prelude hiding (sequence)+import Control.Comonad+import Control.Monad (liftM)+import Data.Functor.Identity+import Data.Functor.Contravariant+import Data.Functor.Contravariant.DualAdjunction++type Adjoint f g = AdjointT f g Identity++newtype AdjointT f g m a = AdjointT { runAdjointT :: f (m (g a)) }++adjoint :: Contravariant f => f (g a) -> Adjoint f g a+adjoint = AdjointT . contramap runIdentity++runAdjoint :: Contravariant f => Adjoint f g a -> f (g a)+runAdjoint = contramap Identity . runAdjointT++instance (Contravariant f, Contravariant g, Monad m) => Functor (AdjointT f g m) where+  fmap f (AdjointT g) = AdjointT $ contramap (liftM (contramap f)) g+  +instance (DualAdjunction f g, Monad m) => Comonad (AdjointT f g m) where+  extract = rightAdjunctOp return . runAdjointT+  extend f = AdjointT . contramap (>>= leftAdjunctOp (f . AdjointT)) . runAdjointT+

@@ -0,0 +1,48 @@+{-# LANGUAGE MultiParamTypeClasses, GADTs #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Density+-- Copyright   :  (C) 2008-2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (GADTs, MPTCs)+--+-- The density comonad for a functor. aka the comonad cogenerated by a functor+-- The ''density'' term dates back to Dubuc''s 1974 thesis. The term +-- ''monad genererated by a functor'' dates back to 1972 in Street''s +-- ''Formal Theory of Monads''.+----------------------------------------------------------------------------+module Control.Comonad.Trans.Density+  ( Density(..)+  , liftDensity+  , densityToAdjunction, adjunctionToDensity+  ) where++import Control.Comonad+import Control.Comonad.Trans.Class+import Data.Functor.Adjunction++data Density k a where+  Density :: (k b -> a) -> k b -> Density k a++instance Functor (Density f) where+  fmap f (Density g h) = Density (f . g) h++instance Comonad (Density f) where+  extract (Density f a) = f a+  duplicate (Density f ws) = Density (Density f) ws++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).+liftDensity :: Comonad w => w a -> Density w a+liftDensity = Density extract ++densityToAdjunction :: Adjunction f g => Density f a -> f (g a)+densityToAdjunction (Density f v) = fmap (leftAdjunct f) v++adjunctionToDensity :: Adjunction f g => f (g a) -> Density f a+adjunctionToDensity = Density counit

@@ -1,50 +0,0 @@-{-# LANGUAGE MultiParamTypeClasses #-}--------------------------------------------------------------------------------- |--- Module      :  Control.Monad.Contra--- Copyright   :  (C) 2011 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  MPTCs, fundeps------ Use a contravariant adjunction to Hask^op to build a 'Comonad' to --- 'Monad' transformer.-------------------------------------------------------------------------------module Control.Monad.Contra-  ( Contra-  , runContra-  , contra-  , ContraT(..)-  ) where--import Prelude hiding (sequence)-import Control.Applicative-import Control.Comonad-import Control.Monad (ap)-import Data.Functor.Identity-import Data.Functor.Contravariant-import Data.Functor.Contravariant.Adjunction--type Contra f g = ContraT f g Identity--newtype ContraT f g w a = ContraT { runContraT :: g (w (f a)) }--contra :: Contravariant g => g (f a) -> Contra f g a-contra = ContraT . contramap runIdentity--runContra :: Contravariant g => Contra f g a -> g (f a)-runContra = contramap Identity . runContraT--instance (Adjunction f g, Functor w) => Functor (ContraT f g w) where-  fmap f (ContraT g) = ContraT $ contramap (fmap (contramap f)) g-  -instance (Adjunction f g, Comonad w) => Applicative (ContraT f g w) where-  pure = ContraT . leftAdjunct extract-  (<*>) = ap--instance (Adjunction f g, Comonad w) => Monad (ContraT f g w) where-  return = ContraT . leftAdjunct extract-  ContraT m >>= f = ContraT $ contramap (extend (rightAdjunct (runContraT . f))) m

@@ -0,0 +1,51 @@+{-# LANGUAGE MultiParamTypeClasses #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Monad.Contra.Adjoint+-- Copyright   :  (C) 2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  MPTCs, fundeps+--+-- Use a contravariant adjunction to Hask^op to build a 'Comonad' to +-- 'Monad' transformer.+----------------------------------------------------------------------------++module Control.Monad.Contra.Adjoint+  ( Adjoint+  , runAdjoint+  , adjoint+  , AdjointT(..)+  ) where++import Prelude hiding (sequence)+import Control.Applicative+import Control.Comonad+import Control.Monad (ap)+import Data.Functor.Identity+import Data.Functor.Contravariant+import Data.Functor.Contravariant.Adjunction++type Adjoint f g = AdjointT f g Identity++newtype AdjointT f g w a = AdjointT { runAdjointT :: g (w (f a)) }++adjoint :: Contravariant g => g (f a) -> Adjoint f g a+adjoint = AdjointT . contramap runIdentity++runAdjoint :: Contravariant g => Adjoint f g a -> g (f a)+runAdjoint = contramap Identity . runAdjointT++instance (Adjunction f g, Functor w) => Functor (AdjointT f g w) where+  fmap f (AdjointT g) = AdjointT $ contramap (fmap (contramap f)) g+  +instance (Adjunction f g, Comonad w) => Applicative (AdjointT f g w) where+  pure = AdjointT . leftAdjunct extract+  (<*>) = ap++instance (Adjunction f g, Comonad w) => Monad (AdjointT f g w) where+  return = AdjointT . leftAdjunct extract+  AdjointT m >>= f = AdjointT $ contramap (extend (rightAdjunct (runAdjointT . f))) m+

@@ -0,0 +1,56 @@+{-# LANGUAGE MultiParamTypeClasses #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Monad.Contra.Cont+-- Copyright   :  (C) 2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  MPTCs, fundeps+--+-- > ContT r ~ AdjointT (Op r) (Op r)+----------------------------------------------------------------------------++module Control.Monad.Contra.Cont+  ( Cont+  , runCont+  , cont+  , ContT(..)+  , callCC+  ) where++import Prelude hiding (sequence)+import Control.Applicative+import Control.Comonad+import Control.Monad (ap)+import Data.Functor.Apply+import Data.Functor.Identity++type Cont r = ContT r Identity++newtype ContT r w a = ContT { runContT :: w (a -> r) -> r }++cont :: ((a -> r) -> r) -> Cont r a+cont f = ContT $ f . runIdentity++runCont :: Cont r a -> (a -> r) -> r+runCont (ContT k) = k . Identity++instance Functor w => Functor (ContT r w) where+  fmap f (ContT k) = ContT $ k . fmap (. f)++instance Comonad w => FunctorApply (ContT r w) where+  (<.>) = ap+  +instance Comonad w => Applicative (ContT r w) where+  pure x = ContT $ \wk -> extract wk x+  (<*>) = ap++instance Comonad w => Monad (ContT r w) where+  return = pure+  ContT k >>= f = ContT $ k . extend (\wa a -> runContT (f a) wa)++callCC :: Comonad w => ((a -> ContT r w b) -> ContT r w a) -> ContT r w a+callCC f = ContT $ \wc -> runContT (f (\a -> ContT $ \_ -> extract wc a)) wc+

@@ -0,0 +1,57 @@+{-# LANGUAGE Rank2Types #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Monad.Trans.Codensity+-- Copyright   :  (C) 2008-2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  provisional+-- Portability :  non-portable (rank-2 polymorphism)+--+----------------------------------------------------------------------------+module Control.Monad.Trans.Codensity+  ( Codensity(..)+  , lowerCodensity+  , codensityToAdjunction+  , adjunctionToCodensity+  ) where++import Control.Applicative+import Control.Monad (ap)+import Data.Functor.Adjunction+import Data.Functor.Apply+import Control.Monad.Trans.Class++newtype Codensity m a = Codensity { runCodensity :: forall b. (a -> m b) -> m b }++instance Functor (Codensity k) where+  fmap f m = Codensity (\k -> runCodensity m (k . f))++instance FunctorApply (Codensity f) where+  (<.>) = ap++instance Applicative (Codensity f) where+  pure x = Codensity (\k -> k x)+  (<*>) = ap++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 (Codensity m) where+  liftIO = liftCodensity . liftIO +-}++instance MonadTrans Codensity where+  lift m = Codensity (m >>=)++lowerCodensity :: Monad m => Codensity m a -> m a+lowerCodensity a = runCodensity a return++codensityToAdjunction :: Adjunction f g => Codensity g a -> g (f a)+codensityToAdjunction r = runCodensity r unit++adjunctionToCodensity :: Adjunction f g => g (f a) -> Codensity g a+adjunctionToCodensity f = Codensity (\a -> fmap (rightAdjunct a) f)

@@ -1,6 +1,6 @@ name:          adjunctions category:      Data Structures, Adjunctions-version:       0.3.1+version:       0.4.0 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -22,14 +22,18 @@     base >= 4 && < 4.4,     contravariant >= 0.1.2 && < 0.2,     comonad >= 0.6.2.1 && < 0.8,+    functor-apply >= 0.7.4 && < 0.8,     comonad-transformers >= 0.6.5 && < 0.8,     transformers >= 0.2.0 && < 0.3    exposed-modules:-    Control.Comonad.Contra+    Control.Comonad.Contra.Adjoint     Control.Comonad.Trans.Adjoint-    Control.Monad.Contra+    Control.Comonad.Trans.Density+    Control.Monad.Contra.Cont+    Control.Monad.Contra.Adjoint     Control.Monad.Trans.Adjoint+    Control.Monad.Trans.Codensity     Data.Functor.Adjunction     Data.Functor.Contravariant.Adjunction     Data.Functor.Contravariant.DualAdjunction