Hello community, here is the log from the commit of package ghc-adjunctions for openSUSE:Factory checked in at 2016-01-30 11:31:48 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-adjunctions (Old) and /work/SRC/openSUSE:Factory/.ghc-adjunctions.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-adjunctions" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-adjunctions/ghc-adjunctions.changes 2015-10-06 13:24:35.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-adjunctions.new/ghc-adjunctions.changes 2016-01-30 11:31:49.000000000 +0100 @@ -1,0 +2,7 @@ +Tue Jan 26 07:58:32 UTC 2016 - mimi.vx@gmail.com + +- update to 4.3 +* Removed a spurious superclass constraint for Applicative (StoreT g w) +* comonad 5 support + +------------------------------------------------------------------- Old: ---- adjunctions-4.2.2.tar.gz New: ---- adjunctions-4.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-adjunctions.spec ++++++ --- /var/tmp/diff_new_pack.8r7GIm/_old 2016-01-30 11:31:50.000000000 +0100 +++ /var/tmp/diff_new_pack.8r7GIm/_new 2016-01-30 11:31:50.000000000 +0100 @@ -19,7 +19,7 @@ %global pkg_name adjunctions Name: ghc-adjunctions -Version: 4.2.2 +Version: 4.3 Release: 0 Summary: Adjunctions and representable functors License: BSD-2-Clause @@ -44,6 +44,7 @@ BuildRequires: ghc-semigroups-devel BuildRequires: ghc-tagged-devel BuildRequires: ghc-transformers-devel +BuildRequires: ghc-transformers-compat-devel BuildRequires: ghc-void-devel # End cabal-rpm deps ++++++ adjunctions-4.2.2.tar.gz -> adjunctions-4.3.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/.travis.yml new/adjunctions-4.3/.travis.yml --- old/adjunctions-4.2.2/.travis.yml 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/.travis.yml 2016-01-17 03:21:47.000000000 +0100 @@ -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]}} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/CHANGELOG.markdown new/adjunctions-4.3/CHANGELOG.markdown --- old/adjunctions-4.2.2/CHANGELOG.markdown 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/CHANGELOG.markdown 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/adjunctions.cabal new/adjunctions-4.3/adjunctions.cabal --- old/adjunctions-4.2.2/adjunctions.cabal 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/adjunctions.cabal 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Control/Comonad/Representable/Store.hs new/adjunctions-4.3/src/Control/Comonad/Representable/Store.hs --- old/adjunctions-4.2.2/src/Control/Comonad/Representable/Store.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Control/Comonad/Representable/Store.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Control/Monad/Representable/Reader.hs new/adjunctions-4.3/src/Control/Monad/Representable/Reader.hs --- old/adjunctions-4.2.2/src/Control/Monad/Representable/Reader.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Control/Monad/Representable/Reader.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Control/Monad/Representable/State.hs new/adjunctions-4.3/src/Control/Monad/Representable/State.hs --- old/adjunctions-4.2.2/src/Control/Monad/Representable/State.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Control/Monad/Representable/State.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Control/Monad/Trans/Adjoint.hs new/adjunctions-4.3/src/Control/Monad/Trans/Adjoint.hs --- old/adjunctions-4.2.2/src/Control/Monad/Trans/Adjoint.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Control/Monad/Trans/Adjoint.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Control/Monad/Trans/Contravariant/Adjoint.hs new/adjunctions-4.3/src/Control/Monad/Trans/Contravariant/Adjoint.hs --- old/adjunctions-4.2.2/src/Control/Monad/Trans/Contravariant/Adjoint.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Control/Monad/Trans/Contravariant/Adjoint.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Data/Functor/Adjunction.hs new/adjunctions-4.3/src/Data/Functor/Adjunction.hs --- old/adjunctions-4.2.2/src/Data/Functor/Adjunction.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Data/Functor/Adjunction.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/adjunctions-4.2.2/src/Data/Functor/Rep.hs new/adjunctions-4.3/src/Data/Functor/Rep.hs --- old/adjunctions-4.2.2/src/Data/Functor/Rep.hs 2015-09-14 01:15:18.000000000 +0200 +++ new/adjunctions-4.3/src/Data/Functor/Rep.hs 2016-01-17 03:21:47.000000000 +0100 @@ -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