Hello community, here is the log from the commit of package ghc-base-orphans for openSUSE:Factory checked in at 2016-02-29 09:14:36 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-base-orphans (Old) and /work/SRC/openSUSE:Factory/.ghc-base-orphans.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-base-orphans" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-base-orphans/ghc-base-orphans.changes 2016-02-11 12:37:24.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-base-orphans.new/ghc-base-orphans.changes 2016-02-29 09:16:08.000000000 +0100 @@ -1,0 +2,8 @@ +Sun Feb 28 21:35:32 UTC 2016 - mimi.vx@gmail.com + +- update to 0.5.2 +* Backported Enum, Bounded, Ix, Functor, Applicative, Monad, MonadFix, MonadPlus, + MonadZip, Foldable, Traversable, and Data instances for datatypes + in the GHC.Generics module (introduced in base-4.9) + +------------------------------------------------------------------- Old: ---- base-orphans-0.5.1.tar.gz New: ---- base-orphans-0.5.2.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-base-orphans.spec ++++++ --- /var/tmp/diff_new_pack.XRmGNm/_old 2016-02-29 09:16:09.000000000 +0100 +++ /var/tmp/diff_new_pack.XRmGNm/_new 2016-02-29 09:16:09.000000000 +0100 @@ -20,7 +20,7 @@ %bcond_with tests Name: ghc-base-orphans -Version: 0.5.1 +Version: 0.5.2 Release: 0 Summary: Backwards-compatible orphan instances for base Group: System/Libraries ++++++ base-orphans-0.5.1.tar.gz -> base-orphans-0.5.2.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.5.1/CHANGES.markdown new/base-orphans-0.5.2/CHANGES.markdown --- old/base-orphans-0.5.1/CHANGES.markdown 2016-02-01 23:14:19.000000000 +0100 +++ new/base-orphans-0.5.2/CHANGES.markdown 2016-02-25 17:46:31.000000000 +0100 @@ -1,3 +1,9 @@ +## Changes in 0.5.2 + - Backported `Enum`, `Bounded`, `Ix`, `Functor`, `Applicative`, `Monad`, + `MonadFix`, `MonadPlus`, `MonadZip`, `Foldable`, `Traversable`, and + `Data` instances for datatypes in the `GHC.Generics` module (introduced in + `base-4.9`) + ## Changes in 0.5.1 - The `Storable` instances for `Complex` and `Ratio` are now exactly as lazy as their counterparts in `base` (see issue diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.5.1/LICENSE new/base-orphans-0.5.2/LICENSE --- old/base-orphans-0.5.1/LICENSE 2016-02-01 23:14:19.000000000 +0100 +++ new/base-orphans-0.5.2/LICENSE 2016-02-25 17:46:31.000000000 +0100 @@ -1,4 +1,4 @@ -Copyright (c) 2015 Simon Hengel <sol@typeful.net>, João Cristóvão <jmacristovao@gmail.com>, Ryan Scott <ryan.gl.scott@gmail.com> +Copyright (c) 2015-2016 Simon Hengel <sol@typeful.net>, João Cristóvão <jmacristovao@gmail.com>, Ryan Scott <ryan.gl.scott@gmail.com> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.5.1/base-orphans.cabal new/base-orphans-0.5.2/base-orphans.cabal --- old/base-orphans-0.5.1/base-orphans.cabal 2016-02-01 23:14:19.000000000 +0100 +++ new/base-orphans-0.5.2/base-orphans.cabal 2016-02-25 17:46:31.000000000 +0100 @@ -1,9 +1,9 @@ --- This file has been generated from package.yaml by hpack version 0.8.0. +-- This file has been generated from package.yaml by hpack version 0.9.1. -- -- see: https://github.com/sol/hpack name: base-orphans -version: 0.5.1 +version: 0.5.2 synopsis: Backwards-compatible orphan instances for base description: @base-orphans@ defines orphan instances that mimic instances available in later versions of @base@ to a wider (older) range of compilers. @base-orphans@ does not export anything except the orphan instances themselves and complements @<http://hackage.haskell.org/package/base-compat base-compat>@. See the README for what instances are covered: <https://github.com/haskell-compat/base-orphans#readme>. See also the <https://github.com/haskell-compat/base-orphans#what-is-not-covered what is not covered> section. @@ -16,9 +16,9 @@ maintainer: Simon Hengel <sol@typeful.net>, João Cristóvão <jmacristovao@gmail.com>, Ryan Scott <ryan.gl.scott@gmail.com> -copyright: (c) 2012-2015 Simon Hengel, - (c) 2014 João Cristóvão, - (c) 2015 Ryan Scott +copyright: (c) 2012-2016 Simon Hengel, + (c) 2014-2016 João Cristóvão, + (c) 2015-2016 Ryan Scott license: MIT license-file: LICENSE build-type: Simple diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.5.1/src/Data/Orphans/Prelude.hs new/base-orphans-0.5.2/src/Data/Orphans/Prelude.hs --- old/base-orphans-0.5.1/src/Data/Orphans/Prelude.hs 2016-02-01 23:14:19.000000000 +0100 +++ new/base-orphans-0.5.2/src/Data/Orphans/Prelude.hs 2016-02-25 17:46:31.000000000 +0100 @@ -16,7 +16,7 @@ (module OrphansPrelude, realPart, imagPart) where import Control.Applicative as OrphansPrelude -import Control.Arrow as OrphansPrelude hiding (loop) +import Control.Arrow as OrphansPrelude hiding (first, loop, second) import Control.Category as OrphansPrelude hiding ((.), id) import Control.Concurrent.QSem as OrphansPrelude import Control.Monad as OrphansPrelude hiding (mapM, sequence) @@ -101,6 +101,7 @@ # endif # if MIN_VERSION_base(4,8,0) +import Data.Bifunctor as OrphansPrelude import Data.Functor.Identity as OrphansPrelude # endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/base-orphans-0.5.1/src/Data/Orphans.hs new/base-orphans-0.5.2/src/Data/Orphans.hs --- old/base-orphans-0.5.1/src/Data/Orphans.hs 2016-02-01 23:14:19.000000000 +0100 +++ new/base-orphans-0.5.2/src/Data/Orphans.hs 2016-02-25 17:46:31.000000000 +0100 @@ -36,7 +36,7 @@ import Control.Monad.ST as Strict #endif -#if __GLASGOW_HASKELL__ >= 701 && __GLASGOW_HASKELL__ < 710 +#if __GLASGOW_HASKELL__ >= 701 && !(MIN_VERSION_base(4,9,0)) import GHC.Generics as Generics #endif @@ -49,6 +49,8 @@ import qualified Data.Foldable as F (Foldable(..)) import Data.Monoid as Monoid import qualified Data.Traversable as T (Traversable(..)) +import Text.ParserCombinators.ReadPrec as ReadPrec +import Text.Read as Read #endif #if __GLASGOW_HASKELL__ < 710 @@ -57,8 +59,6 @@ import GHC.Exts as Exts import GHC.IO.Exception as Exception import Text.ParserCombinators.ReadP as ReadP -import Text.ParserCombinators.ReadPrec as ReadPrec -import Text.Read as Read # if defined(mingw32_HOST_OS) import GHC.ConsoleHandler as Console @@ -623,6 +623,198 @@ deriving instance Monoid a => Monoid (Identity a) deriving instance Storable a => Storable (Identity a) # endif + +# if __GLASGOW_HASKELL__ >= 701 +deriving instance Data p => Data (V1 p) +deriving instance Data p => Data (U1 p) +deriving instance Data p => Data (Par1 p) +deriving instance (Typeable i, Data p, Data c) => Data (K1 i c p) +deriving instance Data Generics.Fixity +deriving instance Data Associativity + +deriving instance F.Foldable V1 +deriving instance F.Foldable U1 +deriving instance F.Foldable Par1 +deriving instance F.Foldable f => F.Foldable (Rec1 f) +deriving instance F.Foldable (K1 i c) +deriving instance F.Foldable f => F.Foldable (M1 i c f) +deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :+: g) +deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :*: g) +deriving instance (F.Foldable f, F.Foldable g) => F.Foldable (f :.: g) + +deriving instance Functor V1 +deriving instance Functor U1 +deriving instance Functor Par1 +deriving instance Functor f => Functor (Rec1 f) +deriving instance Functor (K1 i c) +deriving instance Functor f => Functor (M1 i c f) +deriving instance (Functor f, Functor g) => Functor (f :+: g) +deriving instance (Functor f, Functor g) => Functor (f :*: g) +deriving instance (Functor f, Functor g) => Functor (f :.: g) + +instance MonadFix Par1 where + mfix f = Par1 (fix (unPar1 . f)) + +instance MonadFix f => MonadFix (Rec1 f) where + mfix f = Rec1 (mfix (unRec1 . f)) + +instance MonadFix f => MonadFix (M1 i c f) where + mfix f = M1 (mfix (unM1. f)) + +instance (MonadFix f, MonadFix g) => MonadFix (f :*: g) where + mfix f = (mfix (fstP . f)) :*: (mfix (sndP . f)) + where + fstP (a :*: _) = a + sndP (_ :*: b) = b + +instance MonadZip Par1 where + mzipWith = liftM2 + +instance MonadZip f => MonadZip (Rec1 f) where + mzipWith f (Rec1 fa) (Rec1 fb) = Rec1 (mzipWith f fa fb) + +instance MonadZip f => MonadZip (M1 i c f) where + mzipWith f (M1 fa) (M1 fb) = M1 (mzipWith f fa fb) + +instance (MonadZip f, MonadZip g) => MonadZip (f :*: g) where + mzipWith f (x1 :*: y1) (x2 :*: y2) = mzipWith f x1 x2 :*: mzipWith f y1 y2 + +deriving instance T.Traversable V1 +deriving instance T.Traversable U1 +deriving instance T.Traversable Par1 +deriving instance T.Traversable f => T.Traversable (Rec1 f) +deriving instance T.Traversable (K1 i c) +deriving instance T.Traversable f => T.Traversable (M1 i c f) +deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :+: g) +deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :*: g) +deriving instance (T.Traversable f, T.Traversable g) => T.Traversable (f :.: g) + +deriving instance Bounded Associativity +deriving instance Enum Associativity +deriving instance Ix Associativity + +deriving instance Eq (V1 p) +deriving instance Ord (V1 p) +-- Implement Read instance manually to get around an old GHC bug +-- (Trac #7931) +instance Read (V1 p) where + readPrec = parens ReadPrec.pfail + readList = readListDefault + readListPrec = readListPrecDefault +deriving instance Show (V1 p) + +instance Applicative U1 where + pure _ = U1 + U1 <*> U1 = U1 + +instance Alternative U1 where + empty = U1 + U1 <|> U1 = U1 + +instance Monad U1 where +# if !(MIN_VERSION_base(4,8,0)) + return _ = U1 +# endif + U1 >>= _ = U1 + +instance Applicative Par1 where + pure a = Par1 a + Par1 f <*> Par1 x = Par1 (f x) + +instance Monad Par1 where +# if !(MIN_VERSION_base(4,8,0)) + return a = Par1 a +# endif + Par1 x >>= f = f x + +instance Applicative f => Applicative (Rec1 f) where + pure a = Rec1 (pure a) + Rec1 f <*> Rec1 x = Rec1 (f <*> x) + +instance Alternative f => Alternative (Rec1 f) where + empty = Rec1 empty + Rec1 l <|> Rec1 r = Rec1 (l <|> r) + +instance Monad f => Monad (Rec1 f) where +# if !(MIN_VERSION_base(4,8,0)) + return a = Rec1 (return a) +# endif + Rec1 x >>= f = Rec1 (x >>= \a -> unRec1 (f a)) + +instance MonadPlus f => MonadPlus (Rec1 f) where +# if !(MIN_VERSION_base(4,8,0)) + mzero = Rec1 mzero + mplus (Rec1 a) (Rec1 b) = Rec1 (mplus a b) +# endif + +instance Applicative f => Applicative (M1 i c f) where + pure a = M1 (pure a) + M1 f <*> M1 x = M1 (f <*> x) + +instance Alternative f => Alternative (M1 i c f) where + empty = M1 empty + M1 l <|> M1 r = M1 (l <|> r) + +instance Monad f => Monad (M1 i c f) where +# if !(MIN_VERSION_base(4,8,0)) + return a = M1 (return a) +# endif + M1 x >>= f = M1 (x >>= \a -> unM1 (f a)) + +instance MonadPlus f => MonadPlus (M1 i c f) where +# if !(MIN_VERSION_base(4,8,0)) + mzero = M1 mzero + mplus (M1 a) (M1 b) = M1 (mplus a b) +# endif + +instance (Applicative f, Applicative g) => Applicative (f :*: g) where + pure a = pure a :*: pure a + (f :*: g) <*> (x :*: y) = (f <*> x) :*: (g <*> y) + +instance (Alternative f, Alternative g) => Alternative (f :*: g) where + empty = empty :*: empty + (x1 :*: y1) <|> (x2 :*: y2) = (x1 <|> x2) :*: (y1 <|> y2) + +instance (Monad f, Monad g) => Monad (f :*: g) where +# if !(MIN_VERSION_base(4,8,0)) + return a = return a :*: return a +# endif + (m :*: n) >>= f = (m >>= \a -> fstP (f a)) :*: (n >>= \a -> sndP (f a)) + where + fstP (a :*: _) = a + sndP (_ :*: b) = b + +instance (MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) where +# if !(MIN_VERSION_base(4,8,0)) + mzero = mzero :*: mzero + (x1 :*: y1) `mplus` (x2 :*: y2) = (x1 `mplus` x2) :*: (y1 `mplus` y2) +# endif + +instance (Applicative f, Applicative g) => Applicative (f :.: g) where + pure x = Comp1 (pure (pure x)) + Comp1 f <*> Comp1 x = Comp1 (fmap (<*>) f <*> x) + +instance (Alternative f, Applicative g) => Alternative (f :.: g) where + empty = Comp1 empty + Comp1 x <|> Comp1 y = Comp1 (x <|> y) + +# if MIN_VERSION_base(4,7,0) +deriving instance (Data (f p), Typeable f, Data p) => Data (Rec1 f p) +deriving instance (Data p, Data (f p), Typeable c, Typeable i, Typeable f) + => Data (M1 i c f p) +deriving instance (Typeable f, Typeable g, Data p, Data (f p), Data (g p)) + => Data ((f :+: g) p) +deriving instance (Typeable f, Typeable g, Data p, Data (f p), Data (g p)) + => Data ((f :*: g) p) +deriving instance (Typeable f, Typeable g, Data p, Data (f (g p))) + => Data ((f :.: g) p) +# endif + +# if MIN_VERSION_base(4,8,0) +instance Bifunctor (K1 i) where + bimap f _ (K1 c) = K1 (f c) +# endif +# endif #endif #if __GLASGOW_HASKELL__ < 710