adjunctions 4.2.2 → 4.3

raw patch · 10 files changed

+67/−32 lines, 10 filesdep +transformers-compatdep ~comonaddep ~distributivedep ~transformersPVP ok

version bump matches the API change (PVP)

Dependencies added: transformers-compat

Dependency ranges changed: comonad, distributive, transformers

API changes (from Hackage documentation)

Files

• .travis.yml +4/−4
• CHANGELOG.markdown +6/−0
• adjunctions.cabal +16/−15
• src/Control/Comonad/Representable/Store.hs +1/−1
• src/Control/Monad/Representable/Reader.hs +2/−0
• src/Control/Monad/Representable/State.hs +2/−0
• src/Control/Monad/Trans/Adjoint.hs +1/−1
• src/Control/Monad/Trans/Contravariant/Adjoint.hs +1/−1
• src/Data/Functor/Adjunction.hs +6/−8
• src/Data/Functor/Rep.hs +28/−2

@@ -13,12 +13,12 @@  matrix:   include:-    - env: CABALVER=1.16 GHCVER=7.4.2+    - env: CABALVER=1.24 GHCVER=7.4.2       compiler: ": #GHC 7.4.2"-      addons: {apt: {packages: [cabal-install-1.16,ghc-7.4.2,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}-    - env: CABALVER=1.16 GHCVER=7.6.3+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.4.2,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.6.3       compiler: ": #GHC 7.6.3"-      addons: {apt: {packages: [cabal-install-1.16,ghc-7.6.3,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.6.3,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}     - env: CABALVER=1.18 GHCVER=7.8.4       compiler: ": #GHC 7.8.4"       addons: {apt: {packages: [cabal-install-1.18,ghc-7.8.4,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}

@@ -1,3 +1,9 @@+4.3+---+* Removed a spurious superclass constraint for `Applicative (StoreT g w)`+* GHC 8 support+* `comonad` 5 support+ 4.2.2 ----- * Builds clean on GHC 7.10

@@ -1,6 +1,6 @@ name:          adjunctions category:      Data Structures, Adjunctions-version:       4.2.2+version:       4.3 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -40,20 +40,21 @@     UndecidableInstances    build-depends:-    array         >= 0.3.0.2 && < 0.7,-    base          >= 4       && < 5,-    comonad       >= 4       && < 5,-    containers    >= 0.3     && < 0.6,-    contravariant >= 1       && < 2,-    distributive  >= 0.4     && < 1,-    free          >= 4       && < 5,-    mtl           >= 2.0.1   && < 2.3,-    profunctors   >= 4       && < 6,-    tagged        >= 0.7     && < 1,-    semigroupoids >= 4       && < 6,-    semigroups    >= 0.11    && < 1,-    transformers  >= 0.2     && < 0.5,-    void          >= 0.5.5.1 && < 1+    array               >= 0.3.0.2 && < 0.7,+    base                >= 4       && < 5,+    comonad             >= 4       && < 6,+    containers          >= 0.3     && < 0.6,+    contravariant       >= 1       && < 2,+    distributive        >= 0.4     && < 1,+    free                >= 4       && < 5,+    mtl                 >= 2.0.1   && < 2.3,+    profunctors         >= 4       && < 6,+    tagged              >= 0.7     && < 1,+    semigroupoids       >= 4       && < 6,+    semigroups          >= 0.11    && < 1,+    transformers        >= 0.2     && < 0.6,+    transformers-compat >= 0.3     && < 1,+    void                >= 0.5.5.1 && < 1    exposed-modules:     Control.Comonad.Representable.Store

@@ -95,7 +95,7 @@ instance (ComonadApply w, Semigroup (Rep g), Representable g) => ComonadApply (StoreT g w) where   StoreT ff m <@> StoreT fa n = StoreT (apRep <$> ff <@> fa) (m <> n) -instance (Applicative w, Semigroup (Rep g), Monoid (Rep g), Representable g) => Applicative (StoreT g w) where+instance (Applicative w, Monoid (Rep g), Representable g) => Applicative (StoreT g w) where   pure a = StoreT (pure (pureRep a)) mempty   StoreT ff m <*> StoreT fa n = StoreT (apRep <$> ff <*> fa) (m `mappend` n) 

@@ -77,7 +77,9 @@   ReaderT fm >>- f = ReaderT $ tabulate (\a -> index fm a >>- flip index a . getReaderT . f)  instance (Representable f, Monad m) => Monad (ReaderT f m) where+#if __GLASGOW_HASKELL__ < 710   return = ReaderT . pureRep . return+#endif   ReaderT fm >>= f = ReaderT $ tabulate (\a -> index fm a >>= flip index a . getReaderT . f)  #if __GLASGOW_HASKELL >= 704

@@ -147,7 +147,9 @@   StateT m >>- f = StateT $ fmap (>>- rightAdjunctRep (runStateT . f)) m  instance (Representable g, Monad m) => Monad (StateT g m) where+#if __GLASGOW_VERSION__ < 710   return = StateT . leftAdjunctRep return+#endif   StateT m >>= f = StateT $ fmap (>>= rightAdjunctRep (runStateT . f)) m  instance Representable f => BindTrans (StateT f) where

@@ -50,7 +50,7 @@   (<*>) = ap  instance (Adjunction f g, Monad m) => Monad (AdjointT f g m) where-  return = AdjointT . leftAdjunct return+  return = pure   AdjointT m >>= f = AdjointT $ fmap (>>= rightAdjunct (runAdjointT . f)) m  -- | Exploiting this instance requires that we have the missing Traversables for Identity, (,)e and IdentityT

@@ -62,5 +62,5 @@   (<*>) = ap  instance (Adjunction f g, Comonad w) => Monad (AdjointT f g w) where-  return = AdjointT . leftAdjunct extract+  return = pure   AdjointT m >>= f = AdjointT $ contramap (extend (rightAdjunct (runAdjointT . f))) m

@@ -48,10 +48,10 @@ import Control.Comonad.Trans.Traced  import Data.Functor.Identity-import Data.Functor.Coproduct import Data.Functor.Compose import Data.Functor.Product import Data.Functor.Rep+import Data.Functor.Sum import Data.Profunctor import Data.Void @@ -89,7 +89,7 @@ -- This can be used with the combinators from the @lens@ package. -- -- @'adjuncted' :: 'Adjunction' f u => 'Iso'' (f a -> b) (a -> u b)@-adjuncted :: (Adjunction f u, Profunctor p, Functor g) +adjuncted :: (Adjunction f u, Profunctor p, Functor g)           => p (a -> u b) (g (c -> u d)) -> p (f a -> b) (g (f c -> d)) adjuncted = dimap leftAdjunct (fmap rightAdjunct) {-# INLINE adjuncted #-}@@ -181,12 +181,10 @@   counit = rightAdjunct (rightAdjunct getCompose) . getCompose  instance (Adjunction f g, Adjunction f' g') =>-         Adjunction (Coproduct f f') (Product g g') where-  unit a = Pair (leftAdjunct left a) (leftAdjunct right a)-  counit = coproduct (rightAdjunct fstP) (rightAdjunct sndP)-    where-      fstP (Pair x _) = x-      sndP (Pair _ x) = x+         Adjunction (Sum f f') (Product g g') where+  unit a = Pair (leftAdjunct InL a) (leftAdjunct InR a)+  counit (InL l) = rightAdjunct (\(Pair x _) -> x) l+  counit (InR r) = rightAdjunct (\(Pair _ x) -> x) r  instance Adjunction f u =>          Adjunction (Free f) (Cofree u) where

@@ -67,12 +67,16 @@ import Control.Comonad.Cofree import Control.Monad.Trans.Identity import Control.Monad.Reader+#if MIN_VERSION_base(4,4,0)+import Data.Complex+#endif import Data.Distributive import Data.Functor.Bind import Data.Functor.Identity import Data.Functor.Compose import Data.Functor.Extend import Data.Functor.Product+import qualified Data.Monoid as Monoid import Data.Profunctor import Data.Proxy import Data.Sequence (Seq)@@ -111,7 +115,7 @@ -- This can be used with the combinators from the @lens@ package. -- -- @'tabulated' :: 'Representable' f => 'Iso'' ('Rep' f -> a) (f a)@-tabulated :: (Representable f, Representable g, Profunctor p, Functor h) +tabulated :: (Representable f, Representable g, Profunctor p, Functor h)           => p (f a) (h (g b)) -> p (Rep f -> a) (h (Rep g -> b)) tabulated = dimap tabulate (fmap index) {-# INLINE tabulated #-}@@ -227,6 +231,28 @@       k Seq.:< ks -> index (index as k) ks   tabulate f = f Seq.empty :< tabulate (\k -> tabulate (f . (k Seq.<|))) +instance Representable Monoid.Dual where+  type Rep Monoid.Dual = ()+  index (Monoid.Dual d) () = d+  tabulate f = Monoid.Dual (f ())++instance Representable Monoid.Product where+  type Rep Monoid.Product = ()+  index (Monoid.Product p) () = p+  tabulate f = Monoid.Product (f ())++instance Representable Monoid.Sum where+  type Rep Monoid.Sum = ()+  index (Monoid.Sum s) () = s+  tabulate f = Monoid.Sum (f ())++#if MIN_VERSION_base(4,4,0)+instance Representable Complex where+  type Rep Complex = Bool+  index (r :+ i) key = if key then i else r+  tabulate f = f False :+ f True+#endif+ newtype Co f a = Co { unCo :: f a } deriving Functor  instance Representable f => Representable (Co f) where@@ -248,7 +274,7 @@   (>>-) = bindRep  instance Representable f => Monad (Co f) where-  return = pureRep+  return = pure   (>>=) = bindRep  #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 704