Hello community, here is the log from the commit of package ghc-constraints for openSUSE:Factory checked in at 2017-04-14 13:37:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-constraints (Old) and /work/SRC/openSUSE:Factory/.ghc-constraints.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-constraints" Fri Apr 14 13:37:29 2017 rev:6 rq:485116 version:0.9.1 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-constraints/ghc-constraints.changes 2017-03-14 10:04:34.081190767 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-constraints.new/ghc-constraints.changes 2017-04-14 13:37:29.553329054 +0200 @@ -1,0 +2,5 @@ +Mon Mar 27 12:37:18 UTC 2017 - [email protected] + +- Update to version 0.9.1 with cabal2obs. + +------------------------------------------------------------------- Old: ---- constraints-0.9.tar.gz New: ---- constraints-0.9.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-constraints.spec ++++++ --- /var/tmp/diff_new_pack.fK8WVs/_old 2017-04-14 13:37:30.101251617 +0200 +++ /var/tmp/diff_new_pack.fK8WVs/_new 2017-04-14 13:37:30.105251051 +0200 @@ -18,7 +18,7 @@ %global pkg_name constraints Name: ghc-%{pkg_name} -Version: 0.9 +Version: 0.9.1 Release: 0 Summary: Constraint manipulation License: BSD-2-Clause ++++++ constraints-0.9.tar.gz -> constraints-0.9.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/constraints-0.9/CHANGELOG.markdown new/constraints-0.9.1/CHANGELOG.markdown --- old/constraints-0.9/CHANGELOG.markdown 2017-01-26 03:31:25.000000000 +0100 +++ new/constraints-0.9.1/CHANGELOG.markdown 2017-03-13 15:35:11.000000000 +0100 @@ -1,3 +1,17 @@ +0.9.1 +----- +* Correct an improper use of `unsafeCoerce` in the internals of + `Data.Constraint.Nat` and `Data.Constraint.Symbol` +* Correctly identify the mismatched types when you defer an unsatisfiable + equality constraint through `Data.Constraint.Deferrable` +* Re-export the `(:~~:)` defined in `base` from `Data.Constraint.Deferred` with + GHC 8.2 or later +* Add several new `(:=>)` instances for `Bits`, `Identity`, `Const`, `Natural`, + `IO`, and `Word`. +* Modernize some existing `Class` and `(:=>)` instances to reflect the fact + that `Applicative` is now a superclass of `Monad` on recent versions of + `base`. + 0.9 --- * Changes to `Data.Constraint`: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/constraints-0.9/constraints.cabal new/constraints-0.9.1/constraints.cabal --- old/constraints-0.9/constraints.cabal 2017-01-26 03:31:25.000000000 +0100 +++ new/constraints-0.9.1/constraints.cabal 2017-03-13 15:35:11.000000000 +0100 @@ -1,6 +1,6 @@ name: constraints category: Constraints -version: 0.9 +version: 0.9.1 license: BSD2 cabal-version: >= 1.10 license-file: LICENSE diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/constraints-0.9/src/Data/Constraint/Deferrable.hs new/constraints-0.9.1/src/Data/Constraint/Deferrable.hs --- old/constraints-0.9/src/Data/Constraint/Deferrable.hs 2017-01-26 03:31:25.000000000 +0100 +++ new/constraints-0.9.1/src/Data/Constraint/Deferrable.hs 2017-03-13 15:35:11.000000000 +0100 @@ -51,6 +51,10 @@ import GHC.Types (type (~~)) #endif +#if __GLASGOW_HASKELL__ >= 801 +import Data.Type.Equality ((:~~:)(HRefl)) +#endif + data UnsatisfiedConstraint = UnsatisfiedConstraint String deriving (Typeable, Show) @@ -82,7 +86,7 @@ deferEither_ r = deferEither @p Proxy r #endif -#if __GLASGOW_HASKELL__ >= 800 +#if __GLASGOW_HASKELL__ >= 800 && __GLASGOW_HASKELL__ < 801 -- | Kind heterogeneous propositional equality. Like '(:~:)', @a :~~: b@ is -- inhabited by a terminating value if and only if @a@ is the same type as @b@. -- @@ -112,7 +116,7 @@ deferEither _ r = case cast (Refl :: a :~: a) :: Maybe (a :~: b) of Just Refl -> Right r Nothing -> Left $ - "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `" ++ showTypeRep (Proxy :: Proxy a) ++ "'" + "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `" ++ showTypeRep (Proxy :: Proxy b) ++ "'" #if __GLASGOW_HASKELL__ >= 800 -- | Deferrable heterogenous equality constraints. @@ -122,7 +126,7 @@ deferEither _ r = case cast (HRefl :: a :~~: a) :: Maybe (a :~~: b) of Just HRefl -> Right r Nothing -> Left $ - "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `" ++ showTypeRep (Proxy :: Proxy a) ++ "'" + "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `" ++ showTypeRep (Proxy :: Proxy b) ++ "'" #endif instance (Deferrable a, Deferrable b) => Deferrable (a, b) where diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/constraints-0.9/src/Data/Constraint/Nat.hs new/constraints-0.9.1/src/Data/Constraint/Nat.hs --- old/constraints-0.9/src/Data/Constraint/Nat.hs 2017-01-26 03:31:25.000000000 +0100 +++ new/constraints-0.9.1/src/Data/Constraint/Nat.hs 2017-03-13 15:35:11.000000000 +0100 @@ -54,10 +54,10 @@ type Divides n m = n ~ Gcd n m -newtype Magic n r = Magic (KnownNat n => r) +newtype Magic n = Magic (KnownNat n => Dict (KnownNat n)) magic :: forall n m o. (Integer -> Integer -> Integer) -> (KnownNat n, KnownNat m) :- KnownNat o -magic f = Sub $ unsafeCoerce (Magic id) (natVal (Proxy :: Proxy n) `f` natVal (Proxy :: Proxy m)) +magic f = Sub $ unsafeCoerce (Magic Dict) (natVal (Proxy :: Proxy n) `f` natVal (Proxy :: Proxy m)) axiom :: forall a b. Dict (a ~ b) axiom = unsafeCoerce (Dict :: Dict (a ~ a)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/constraints-0.9/src/Data/Constraint/Symbol.hs new/constraints-0.9.1/src/Data/Constraint/Symbol.hs --- old/constraints-0.9/src/Data/Constraint/Symbol.hs 2017-01-26 03:31:25.000000000 +0100 +++ new/constraints-0.9.1/src/Data/Constraint/Symbol.hs 2017-03-13 15:35:11.000000000 +0100 @@ -48,16 +48,16 @@ -- implementation details -newtype Magic n r = Magic (KnownSymbol n => r) +newtype Magic n = Magic (KnownSymbol n => Dict (KnownSymbol n)) magicNSS :: forall n m o. (Int -> String -> String) -> (KnownNat n, KnownSymbol m) :- KnownSymbol o -magicNSS f = Sub $ unsafeCoerce (Magic id) (fromIntegral (natVal (Proxy :: Proxy n)) `f` symbolVal (Proxy :: Proxy m)) +magicNSS f = Sub $ unsafeCoerce (Magic Dict) (fromIntegral (natVal (Proxy :: Proxy n)) `f` symbolVal (Proxy :: Proxy m)) magicSSS :: forall n m o. (String -> String -> String) -> (KnownSymbol n, KnownSymbol m) :- KnownSymbol o -magicSSS f = Sub $ unsafeCoerce (Magic id) (symbolVal (Proxy :: Proxy n) `f` symbolVal (Proxy :: Proxy m)) +magicSSS f = Sub $ unsafeCoerce (Magic Dict) (symbolVal (Proxy :: Proxy n) `f` symbolVal (Proxy :: Proxy m)) magicSN :: forall a n. (String -> Int) -> KnownSymbol a :- KnownNat n -magicSN f = Sub $ unsafeCoerce (Magic id) (toInteger (f (symbolVal (Proxy :: Proxy a)))) +magicSN f = Sub $ unsafeCoerce (Magic Dict) (toInteger (f (symbolVal (Proxy :: Proxy a)))) axiom :: forall a b. Dict (a ~ b) axiom = unsafeCoerce (Dict :: Dict (a ~ a)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/constraints-0.9/src/Data/Constraint.hs new/constraints-0.9.1/src/Data/Constraint.hs --- old/constraints-0.9/src/Data/Constraint.hs 2017-01-26 03:31:25.000000000 +0100 +++ new/constraints-0.9.1/src/Data/Constraint.hs 2017-03-13 15:35:11.000000000 +0100 @@ -84,6 +84,14 @@ import Data.Data import qualified GHC.Exts as Exts (Any) import GHC.Exts (Constraint) +import Data.Bits (Bits) +import Data.Functor.Identity (Identity) +#if MIN_VERSION_base(4,8,0) +import Numeric.Natural (Natural) +#endif +#if !MIN_VERSION_base(4,8,0) +import Data.Word (Word) +#endif -- | Values of type @'Dict' p@ capture a dictionary for a constraint of type @p@. -- @@ -172,7 +180,7 @@ -- What are the two ways? -- -- Well, we can go from @'Ord' a ':-' 'Eq' a@ via the --- superclass relationship, and them from @'Eq' a ':-' 'Eq' [a]@ via the +-- superclass relationship, and then from @'Eq' a ':-' 'Eq' [a]@ via the -- instance, or we can go from @'Ord' a ':-' 'Ord' [a]@ via the instance -- then from @'Ord' [a] ':-' 'Eq' [a]@ through the superclass relationship -- and this diagram by definition must \"commute\". @@ -406,6 +414,12 @@ instance (Eq a, Eq b) :=> Eq (Either a b) where ins = Sub Dict instance () :=> Eq (Dict a) where ins = Sub Dict instance () :=> Eq (a :- b) where ins = Sub Dict +instance () :=> Eq Word where ins = Sub Dict +instance Eq a :=> Eq (Identity a) where ins = Sub Dict +#if MIN_VERSION_base(4,8,0) +instance Eq a :=> Eq (Const a b) where ins = Sub Dict +instance () :=> Eq Natural where ins = Sub Dict +#endif -- Ord instance Class (Eq a) (Ord a) where cls = Sub Dict @@ -423,6 +437,12 @@ instance Integral a :=> Ord (Ratio a) where ins = Sub Dict instance () :=> Ord (Dict a) where ins = Sub Dict instance () :=> Ord (a :- b) where ins = Sub Dict +instance () :=> Ord Word where ins = Sub Dict +instance Ord a :=> Ord (Identity a) where ins = Sub Dict +#if MIN_VERSION_base(4,8,0) +instance Ord a :=> Ord (Const a b) where ins = Sub Dict +instance () :=> Ord Natural where ins = Sub Dict +#endif -- Show instance Class () (Show a) where cls = Sub Dict @@ -438,6 +458,12 @@ instance (Integral a, Show a) :=> Show (Ratio a) where ins = Sub Dict instance () :=> Show (Dict a) where ins = Sub Dict instance () :=> Show (a :- b) where ins = Sub Dict +instance () :=> Show Word where ins = Sub Dict +instance Show a :=> Show (Identity a) where ins = Sub Dict +#if MIN_VERSION_base(4,8,0) +instance Show a :=> Show (Const a b) where ins = Sub Dict +instance () :=> Show Natural where ins = Sub Dict +#endif -- Read instance Class () (Read a) where cls = Sub Dict @@ -451,6 +477,12 @@ instance (Read a, Read b) :=> Read (a, b) where ins = Sub Dict instance (Read a, Read b) :=> Read (Either a b) where ins = Sub Dict instance (Integral a, Read a) :=> Read (Ratio a) where ins = Sub Dict +instance () :=> Read Word where ins = Sub Dict +instance Read a :=> Read (Identity a) where ins = Sub Dict +#if MIN_VERSION_base(4,8,0) +instance Read a :=> Read (Const a b) where ins = Sub Dict +instance () :=> Read Natural where ins = Sub Dict +#endif -- Enum instance Class () (Enum a) where cls = Sub Dict @@ -463,6 +495,14 @@ instance () :=> Enum Float where ins = Sub Dict instance () :=> Enum Double where ins = Sub Dict instance Integral a :=> Enum (Ratio a) where ins = Sub Dict +instance () :=> Enum Word where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Enum a :=> Enum (Identity a) where ins = Sub Dict +instance Enum a :=> Enum (Const a b) where ins = Sub Dict +#endif +#if MIN_VERSION_base(4,8,0) +instance () :=> Enum Natural where ins = Sub Dict +#endif -- Bounded instance Class () (Bounded a) where cls = Sub Dict @@ -472,6 +512,11 @@ instance () :=> Bounded Int where ins = Sub Dict instance () :=> Bounded Char where ins = Sub Dict instance (Bounded a, Bounded b) :=> Bounded (a,b) where ins = Sub Dict +instance () :=> Bounded Word where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Bounded a :=> Bounded (Identity a) where ins = Sub Dict +instance Bounded a :=> Bounded (Const a b) where ins = Sub Dict +#endif -- Num instance Class () (Num a) where cls = Sub Dict @@ -481,6 +526,14 @@ instance () :=> Num Double where ins = Sub Dict instance RealFloat a :=> Num (Complex a) where ins = Sub Dict instance Integral a :=> Num (Ratio a) where ins = Sub Dict +instance () :=> Num Word where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Num a :=> Num (Identity a) where ins = Sub Dict +instance Num a :=> Num (Const a b) where ins = Sub Dict +#endif +#if MIN_VERSION_base(4,8,0) +instance () :=> Num Natural where ins = Sub Dict +#endif -- Real instance Class (Num a, Ord a) (Real a) where cls = Sub Dict @@ -489,11 +542,41 @@ instance () :=> Real Float where ins = Sub Dict instance () :=> Real Double where ins = Sub Dict instance Integral a :=> Real (Ratio a) where ins = Sub Dict +instance () :=> Real Word where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Real a :=> Real (Identity a) where ins = Sub Dict +instance Real a :=> Real (Const a b) where ins = Sub Dict +#endif +#if MIN_VERSION_base(4,8,0) +instance () :=> Real Natural where ins = Sub Dict +#endif -- Integral instance Class (Real a, Enum a) (Integral a) where cls = Sub Dict instance () :=> Integral Int where ins = Sub Dict instance () :=> Integral Integer where ins = Sub Dict +instance () :=> Integral Word where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Integral a :=> Integral (Identity a) where ins = Sub Dict +instance Integral a :=> Integral (Const a b) where ins = Sub Dict +#endif +#if MIN_VERSION_base(4,8,0) +instance () :=> Integral Natural where ins = Sub Dict +#endif + +-- Bits +instance Class (Eq a) (Bits a) where cls = Sub Dict +instance () :=> Bits Bool where ins = Sub Dict +instance () :=> Bits Int where ins = Sub Dict +instance () :=> Bits Integer where ins = Sub Dict +instance () :=> Bits Word where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Bits a :=> Bits (Identity a) where ins = Sub Dict +instance Bits a :=> Bits (Const a b) where ins = Sub Dict +#endif +#if MIN_VERSION_base(4,8,0) +instance () :=> Bits Natural where ins = Sub Dict +#endif -- Fractional instance Class (Num a) (Fractional a) where cls = Sub Dict @@ -501,23 +584,39 @@ instance () :=> Fractional Double where ins = Sub Dict instance RealFloat a :=> Fractional (Complex a) where ins = Sub Dict instance Integral a :=> Fractional (Ratio a) where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Fractional a :=> Fractional (Identity a) where ins = Sub Dict +instance Fractional a :=> Fractional (Const a b) where ins = Sub Dict +#endif -- Floating instance Class (Fractional a) (Floating a) where cls = Sub Dict instance () :=> Floating Float where ins = Sub Dict instance () :=> Floating Double where ins = Sub Dict instance RealFloat a :=> Floating (Complex a) where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Floating a :=> Floating (Identity a) where ins = Sub Dict +instance Floating a :=> Floating (Const a b) where ins = Sub Dict +#endif -- RealFrac instance Class (Real a, Fractional a) (RealFrac a) where cls = Sub Dict instance () :=> RealFrac Float where ins = Sub Dict instance () :=> RealFrac Double where ins = Sub Dict instance Integral a :=> RealFrac (Ratio a) where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance RealFrac a :=> RealFrac (Identity a) where ins = Sub Dict +instance RealFrac a :=> RealFrac (Const a b) where ins = Sub Dict +#endif -- RealFloat instance Class (RealFrac a, Floating a) (RealFloat a) where cls = Sub Dict instance () :=> RealFloat Float where ins = Sub Dict instance () :=> RealFloat Double where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance RealFloat a :=> RealFloat (Identity a) where ins = Sub Dict +instance RealFloat a :=> RealFloat (Const a b) where ins = Sub Dict +#endif -- Monoid instance Class () (Monoid a) where cls = Sub Dict @@ -526,6 +625,13 @@ instance () :=> Monoid [a] where ins = Sub Dict instance Monoid a :=> Monoid (Maybe a) where ins = Sub Dict instance (Monoid a, Monoid b) :=> Monoid (a, b) where ins = Sub Dict +instance Monoid a :=> Monoid (Const a b) where ins = Sub Dict +#if MIN_VERSION_base(4,9,0) +instance Monoid a :=> Monoid (Identity a) where ins = Sub Dict +#endif +#if MIN_VERSION_base(4,9,0) +instance Monoid a :=> Monoid (IO a) where ins = Sub Dict +#endif -- Functor instance Class () (Functor f) where cls = Sub Dict @@ -536,6 +642,8 @@ instance () :=> Functor ((,) a) where ins = Sub Dict instance () :=> Functor IO where ins = Sub Dict instance Monad m :=> Functor (WrappedMonad m) where ins = Sub Dict +instance () :=> Functor Identity where ins = Sub Dict +instance () :=> Functor (Const a) where ins = Sub Dict -- Applicative instance Class (Functor f) (Applicative f) where cls = Sub Dict @@ -545,6 +653,7 @@ instance () :=> Applicative ((->)a) where ins = Sub Dict instance () :=> Applicative IO where ins = Sub Dict instance Monoid a :=> Applicative ((,)a) where ins = Sub Dict +instance Monoid a :=> Applicative (Const a) where ins = Sub Dict instance Monad m :=> Applicative (WrappedMonad m) where ins = Sub Dict -- Alternative @@ -554,14 +663,23 @@ instance MonadPlus m :=> Alternative (WrappedMonad m) where ins = Sub Dict -- Monad +#if MIN_VERSION_base(4,8,0) +instance Class (Applicative f) (Monad f) where cls = Sub Dict +#else instance Class () (Monad f) where cls = Sub Dict +#endif instance () :=> Monad [] where ins = Sub Dict instance () :=> Monad ((->) a) where ins = Sub Dict instance () :=> Monad (Either a) where ins = Sub Dict instance () :=> Monad IO where ins = Sub Dict +instance () :=> Monad Identity where ins = Sub Dict -- MonadPlus +#if MIN_VERSION_base(4,8,0) +instance Class (Monad f, Alternative f) (MonadPlus f) where cls = Sub Dict +#else instance Class (Monad f) (MonadPlus f) where cls = Sub Dict +#endif instance () :=> MonadPlus [] where ins = Sub Dict instance () :=> MonadPlus Maybe where ins = Sub Dict
