commit ghc-ghc-typelits-knownnat for openSUSE:Factory

31 Aug 2017

Hello community,

here is the log from the commit of package ghc-ghc-typelits-knownnat for openSUSE:Factory checked in at 2017-08-31 20:51:01
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-ghc-typelits-knownnat (Old)
 and      /work/SRC/openSUSE:Factory/.ghc-ghc-typelits-knownnat.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "ghc-ghc-typelits-knownnat"

Thu Aug 31 20:51:01 2017 rev:3 rq:513251 version:0.3

Changes:
--------

--- /work/SRC/openSUSE:Factory/ghc-ghc-typelits-knownnat/ghc-ghc-typelits-knownnat.changes	2017-05-17 10:55:28.849317587 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-ghc-typelits-knownnat.new/ghc-ghc-typelits-knownnat.changes	2017-08-31 20:51:03.604956788 +0200
@@ -1,0 +2,5 @@
+Thu Jul 27 14:03:45 UTC 2017 - psimons@suse.com
+
+- Update to version 0.3.
+
+-------------------------------------------------------------------

Old:
----
  ghc-typelits-knownnat-0.2.4.tar.gz

New:
----
  ghc-typelits-knownnat-0.3.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ ghc-ghc-typelits-knownnat.spec ++++++
--- /var/tmp/diff_new_pack.pSs4N2/_old	2017-08-31 20:51:04.600816997 +0200
+++ /var/tmp/diff_new_pack.pSs4N2/_new	2017-08-31 20:51:04.608815875 +0200
@@ -19,7 +19,7 @@
 %global pkg_name ghc-typelits-knownnat
 %bcond_with tests
 Name:           ghc-%{pkg_name}
-Version:        0.2.4
+Version:        0.3
 Release:        0
 Summary:        Derive KnownNat constraints from other KnownNat constraints
 License:        BSD-2-Clause

++++++ ghc-typelits-knownnat-0.2.4.tar.gz -> ghc-typelits-knownnat-0.3.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ghc-typelits-knownnat-0.2.4/CHANGELOG.md new/ghc-typelits-knownnat-0.3/CHANGELOG.md
--- old/ghc-typelits-knownnat-0.2.4/CHANGELOG.md	2017-04-10 17:31:37.000000000 +0200
+++ new/ghc-typelits-knownnat-0.3/CHANGELOG.md	2017-05-15 10:14:32.000000000 +0200
@@ -1,5 +1,8 @@
 # Changelog for the [`ghc-typelits-knownnat`](http://hackage.haskell.org/package/ghc-typelits-knownnat) package
 
+## 0.3 *May 15th 2017*
+* GHC 8.2.1 support: Underlying representation for `KnownNat` in GHC 8.2 is `Natural`, meaning users of this plugin will need to update their code to use `Natural` for GHC 8.2 as well.
+
 ## 0.2.4 *April 10th 2017*
 * New features:
   * Derive constraints for unary functions via a `KnownNat1` instance; thanks to @nshepperd [#11](https://github.com/clash-lang/ghc-typelits-knownnat/pull/11)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ghc-typelits-knownnat-0.2.4/ghc-typelits-knownnat.cabal new/ghc-typelits-knownnat-0.3/ghc-typelits-knownnat.cabal
--- old/ghc-typelits-knownnat-0.2.4/ghc-typelits-knownnat.cabal	2017-04-10 17:27:52.000000000 +0200
+++ new/ghc-typelits-knownnat-0.3/ghc-typelits-knownnat.cabal	2017-05-02 10:09:20.000000000 +0200
@@ -1,5 +1,5 @@
 name:                ghc-typelits-knownnat
-version:             0.2.4
+version:             0.3
 synopsis:            Derive KnownNat constraints from other KnownNat constraints
 description:
   A type checker plugin for GHC that can derive \"complex\" @KnownNat@
@@ -81,8 +81,8 @@
                        TypeInType
                        UndecidableInstances
                        ViewPatterns
-  build-depends:       base                      >= 4.9      && <4.10,
-                       ghc                       >= 8.0.1    && <8.2,
+  build-depends:       base                      >= 4.9      && <5,
+                       ghc                       >= 8.0.1    && <8.4,
                        ghc-tcplugins-extra       >= 0.2,
                        ghc-typelits-natnormalise >= 0.5.2    && <0.6,
                        singletons                >= 2.2      && <3.0,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ghc-typelits-knownnat-0.2.4/src/GHC/TypeLits/KnownNat.hs new/ghc-typelits-knownnat-0.3/src/GHC/TypeLits/KnownNat.hs
--- old/ghc-typelits-knownnat-0.2.4/src/GHC/TypeLits/KnownNat.hs	2017-04-10 17:27:52.000000000 +0200
+++ new/ghc-typelits-knownnat-0.3/src/GHC/TypeLits/KnownNat.hs	2017-05-02 10:03:24.000000000 +0200
@@ -85,6 +85,7 @@
 -}
 
 {-# LANGUAGE AllowAmbiguousTypes   #-}
+{-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE KindSignatures        #-}
@@ -116,15 +117,29 @@
 
 import Data.Bits              (shiftL)
 import Data.Proxy             (Proxy (..))
+#if MIN_VERSION_ghc(8,2,0)
+import GHC.TypeNats
+  (KnownNat, Nat, type (+), type (*), type (^), type (-), type (<=), natVal)
+import GHC.TypeLits           (Symbol)
+#else
 import GHC.TypeLits           (KnownNat, Nat, Symbol, type (+), type (*),
                                type (^), type (-), type (<=), natVal)
+#endif
 import Data.Singletons        (type (~>), type (@@))
 import Data.Promotion.Prelude (type (:+$), type (:*$), type (:^$), type (:-$))
+#if MIN_VERSION_ghc(8,2,0)
+import Numeric.Natural        (Natural)
+#endif
 
 import GHC.TypeLits.KnownNat.TH
 
--- | Singleton natural number (represented by an integer)
-newtype SNatKn (n :: Nat) = SNatKn Integer
+-- | Singleton natural number
+newtype SNatKn (n :: Nat) =
+#if MIN_VERSION_ghc(8,2,0)
+  SNatKn Natural
+#else
+  SNatKn Integer
+#endif
 
 -- | Class for arithmetic functions with /one/ argument.
 --
@@ -171,7 +186,7 @@
   natSing2 = let x = natVal (Proxy @ a)
                  y = natVal (Proxy @ b)
                  z = case x of
-                       2 -> shiftL 1 (fromInteger y)
+                       2 -> shiftL 1 (fromIntegral y)
                        _ -> x ^ y
              in  SNatKn z
   {-# INLINE natSing2 #-}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ghc-typelits-knownnat-0.2.4/tests/Main.hs new/ghc-typelits-knownnat-0.3/tests/Main.hs
--- old/ghc-typelits-knownnat-0.2.4/tests/Main.hs	2017-04-10 17:27:52.000000000 +0200
+++ new/ghc-typelits-knownnat-0.3/tests/Main.hs	2017-05-02 10:23:58.000000000 +0200
@@ -1,4 +1,4 @@
-{-# LANGUAGE DataKinds, GADTs, KindSignatures, ScopedTypeVariables, TypeOperators,
+{-# LANGUAGE CPP, DataKinds, GADTs, KindSignatures, ScopedTypeVariables, TypeOperators,
              TypeApplications, TypeFamilies, TypeFamilyDependencies, FlexibleContexts #-}
 
 {-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise       #-}
@@ -8,7 +8,12 @@
 
 import Data.Proxy
 import Data.Type.Equality ((:~:)(..))
+#if __GLASGOW_HASKELL__ >= 802
+import GHC.TypeNats
+import Numeric.Natural
+#else
 import GHC.TypeLits
+#endif
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.QuickCheck
@@ -16,14 +21,20 @@
 
 import TestFunctions
 
-addT :: Integer -> Integer -> Integer
+#if __GLASGOW_HASKELL__ >= 802
+type Number = Natural
+#else
+type Number = Integer
+#endif
+
+addT :: Number -> Number -> Number
 addT a b = withNat a $
            \(Proxy :: Proxy a) ->
              withNat b $
              \(Proxy :: Proxy b) ->
                natVal (Proxy :: Proxy (a + b))
 
-subT :: Integer -> Integer -> Integer
+subT :: Number -> Number -> Number
 subT a b
   | a >= b = withNat a $
              \(Proxy :: Proxy a) ->
@@ -34,77 +45,77 @@
                      natVal (Proxy :: Proxy (a - b))
   | otherwise = error "a - b < 0"
 
-mulT :: Integer -> Integer -> Integer
+mulT :: Number -> Number -> Number
 mulT a b = withNat a $
            \(Proxy :: Proxy a) ->
              withNat b $
              \(Proxy :: Proxy b) ->
                natVal (Proxy :: Proxy (a * b))
 
-maxT :: Integer -> Integer -> Integer
+maxT :: Number -> Number -> Number
 maxT a b = withNat a $
            \(Proxy :: Proxy a) ->
              withNat b $
              \(Proxy :: Proxy b) ->
                natVal (Proxy :: Proxy (Max a b))
 
-logT :: Integer -> Integer
+logT :: Number -> Number
 logT n = withNat n $ \(Proxy :: Proxy n) ->
                            natVal (Proxy :: Proxy (Log n))
 
-test1 :: forall n . KnownNat n => Proxy n -> Integer
+test1 :: forall n . KnownNat n => Proxy n -> Number
 test1 _ = natVal (Proxy :: Proxy n) + natVal (Proxy :: Proxy (n+2))
 
-test2 :: forall n . KnownNat n => Proxy n -> Integer
+test2 :: forall n . KnownNat n => Proxy n -> Number
 test2 _ = natVal (Proxy :: Proxy (n*3))
 
-test3 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Integer
+test3 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Number
 test3 _ _ = natVal (Proxy :: Proxy (n+m))
 
-test4 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Integer
+test4 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Number
 test4 _ _ = natVal (Proxy :: Proxy (n*m))
 
-test5 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Integer
+test5 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Number
 test5 _ _ = natVal (Proxy :: Proxy (n^m))
 
-test6 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Integer
+test6 :: forall n m . (KnownNat n, KnownNat m) => Proxy n -> Proxy m -> Number
 test6 _ _ = natVal (Proxy :: Proxy ((n^m)+(n*m)))
 
-test7 :: forall n m . (KnownNat m, KnownNat n) => Proxy n -> Proxy m -> Integer
+test7 :: forall n m . (KnownNat m, KnownNat n) => Proxy n -> Proxy m -> Number
 test7 _ _ = natVal (Proxy :: Proxy (Max n m + 1))
 
-test8 :: forall n m . (KnownNat (Min n m)) => Proxy n -> Proxy m -> Integer
+test8 :: forall n m . (KnownNat (Min n m)) => Proxy n -> Proxy m -> Number
 test8 _ _ = natVal (Proxy :: Proxy (Min n m + 1))
 
-test9 :: forall n m . (KnownNat m, KnownNat n, n <= m) => Proxy m -> Proxy n -> Integer
+test9 :: forall n m . (KnownNat m, KnownNat n, n <= m) => Proxy m -> Proxy n -> Number
 test9 _ _ = natVal (Proxy :: Proxy (m-n))
 
-test10 :: forall (n :: Nat) m . (KnownNat m) => Proxy m -> Proxy n -> Integer
+test10 :: forall (n :: Nat) m . (KnownNat m) => Proxy m -> Proxy n -> Number
 test10 _ _ = natVal (Proxy :: Proxy (m-n+n))
 
-test11 :: forall m . (KnownNat m) => Proxy m -> Integer
+test11 :: forall m . (KnownNat m) => Proxy m -> Number
 test11 _ = natVal (Proxy @ (m*m))
 
-test12 :: forall m . (KnownNat (m+1)) => Proxy m -> Integer
+test12 :: forall m . (KnownNat (m+1)) => Proxy m -> Number
 test12 = natVal
 
-test13 :: forall m . (KnownNat (m+3)) => Proxy m -> Integer
+test13 :: forall m . (KnownNat (m+3)) => Proxy m -> Number
 test13 = natVal
 
-test14 :: forall m . (KnownNat (4+m)) => Proxy (7+m) -> Integer
+test14 :: forall m . (KnownNat (4+m)) => Proxy (7+m) -> Number
 test14 = natVal
 
 type family Foo (m :: Nat) = (result :: Nat) | result -> m
 fakeFooEvidence :: 1 :~: Foo 1
 fakeFooEvidence = unsafeCoerce Refl
 
-test15 :: KnownNat (4 + Foo 1) => Proxy (Foo 1) -> Proxy (4 + Foo 1) -> Integer
+test15 :: KnownNat (4 + Foo 1) => Proxy (Foo 1) -> Proxy (4 + Foo 1) -> Number
 test15 _ _ = natVal (Proxy @ (Foo 1 + 7))
 
-test16 :: KnownNat (4 + Foo 1 + Foo 1) => Proxy (Foo 1) -> Proxy (4 + Foo 1 + Foo 1) -> Integer
+test16 :: KnownNat (4 + Foo 1 + Foo 1) => Proxy (Foo 1) -> Proxy (4 + Foo 1 + Foo 1) -> Number
 test16 _ _ = natVal (Proxy @ (Foo 1 + 7 + Foo 1))
 
-test17 :: KnownNat (4 + 2 * Foo 1 + Foo 1) => Proxy (Foo 1) -> Proxy (4 + 2 * Foo 1 + Foo 1) -> Integer
+test17 :: KnownNat (4 + 2 * Foo 1 + Foo 1) => Proxy (Foo 1) -> Proxy (4 + 2 * Foo 1 + Foo 1) -> Number
 test17 _ _ = natVal (Proxy @ (2 * Foo 1 + 7 + Foo 1))
 
 data SNat :: Nat -> * where
@@ -131,19 +142,19 @@
 test19 :: SNat (a+b) -> SNat b -> SNat a
 test19 = subSNat
 
-test20 :: forall a . (KnownNat (3 * a - a)) => Proxy a -> Integer
+test20 :: forall a . (KnownNat (3 * a - a)) => Proxy a -> Number
 test20 _ = natVal (Proxy @ (2 * a))
 
-test21 :: forall m n . (KnownNat (m+n), KnownNat m) => Proxy (m+n) -> Proxy m -> Integer
+test21 :: forall m n . (KnownNat (m+n), KnownNat m) => Proxy (m+n) -> Proxy m -> Number
 test21 _ _ = natVal (Proxy :: Proxy n)
 
-test22 :: forall x y . (KnownNat x, KnownNat y) => Proxy x -> Proxy y -> Integer
+test22 :: forall x y . (KnownNat x, KnownNat y) => Proxy x -> Proxy y -> Number
 test22 _ _ = natVal (Proxy :: Proxy (y*x*y))
 
 test23 :: SNat addrSize -> SNat ((addrSize + 1) - (addrSize - 1))
 test23 SNat = SNat
 
-test24 :: (KnownNat n, n ~ (m+1)) => proxy m -> Integer
+test24 :: (KnownNat n, n ~ (m+1)) => proxy m -> Number
 test24 = natVal
 
 tests :: TestTree
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/ghc-typelits-knownnat-0.2.4/tests/TestFunctions.hs new/ghc-typelits-knownnat-0.3/tests/TestFunctions.hs
--- old/ghc-typelits-knownnat-0.2.4/tests/TestFunctions.hs	2017-04-10 17:27:52.000000000 +0200
+++ new/ghc-typelits-knownnat-0.3/tests/TestFunctions.hs	2017-05-02 10:50:43.000000000 +0200
@@ -1,4 +1,4 @@
-{-# LANGUAGE DataKinds, FlexibleInstances, GADTs, KindSignatures,
+{-# LANGUAGE CPP, DataKinds, FlexibleInstances, GADTs, KindSignatures,
              MultiParamTypeClasses, RankNTypes, ScopedTypeVariables, TemplateHaskell,
              TypeApplications, TypeFamilies, TypeOperators,
              UndecidableInstances #-}
@@ -9,7 +9,12 @@
 import Data.Singletons.TH    (genDefunSymbols)
 import Data.Type.Bool        (If)
 import GHC.TypeLits.KnownNat
+#if __GLASGOW_HASKELL__ >= 802
+import GHC.TypeNats
+import Numeric.Natural
+#else
 import GHC.TypeLits
+#endif
 
 type family Max (a :: Nat) (b :: Nat) :: Nat where
   Max 0 b = b -- See [Note: single equation TFs are treated like synonyms]
@@ -38,17 +43,26 @@
   Min a b = If (a <=? b) a b
 
 -- Unary functions.
-
+#if __GLASGOW_HASKELL__ >= 802
+withNat :: Natural -> (forall n. (KnownNat n) => Proxy n -> r) -> r
+withNat n f = case someNatVal n of
+  SomeNat proxy -> f proxy
+#else
 withNat :: Integer -> (forall n. (KnownNat n) => Proxy n -> r) -> r
 withNat n f = case someNatVal n of
                Just (SomeNat proxy) -> f proxy
                Nothing              -> error ("withNat: negative value (" ++ show n ++ ")")
+#endif
 
 type family Log (n :: Nat) :: Nat where
 
 genDefunSymbols [''Log]
 
+#if __GLASGOW_HASKELL__ >= 802
+logInt :: Natural -> Natural
+#else
 logInt :: Integer -> Integer
+#endif
 logInt 0 = error "log 0"
 logInt n = go 0
   where

    

commit ghc-ghc-typelits-knownnat for openSUSE:Factory

root＠hilbert.suse.de