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 , João Cristóvão , Ryan Scott
+Copyright (c) 2015-2016 Simon Hengel , João Cristóvão , Ryan Scott
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 ,
João Cristóvão ,
Ryan Scott
-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
