run ./regen.sh

Author: infinity0

contrib/containers

@@ -12,30 +12,19 @@
 #include "MachDeps.h"
 #endif
 
-/*
- * Define INSTANCE_TYPEABLE[0-2]
- */
-#if __GLASGOW_HASKELL__ >= 707
-#define INSTANCE_TYPEABLE0(tycon) deriving instance Typeable tycon
-#define INSTANCE_TYPEABLE1(tycon) deriving instance Typeable tycon
-#define INSTANCE_TYPEABLE2(tycon) deriving instance Typeable tycon
-#elif defined(__GLASGOW_HASKELL__)
-#define INSTANCE_TYPEABLE0(tycon) deriving instance Typeable tycon
-#define INSTANCE_TYPEABLE1(tycon) deriving instance Typeable1 tycon
-#define INSTANCE_TYPEABLE2(tycon) deriving instance Typeable2 tycon
-#else
-#define INSTANCE_TYPEABLE0(tycon)
-#define INSTANCE_TYPEABLE1(tycon)
-#define INSTANCE_TYPEABLE2(tycon)
-#endif
-
-#if __GLASGOW_HASKELL__ >= 800
+#ifdef __GLASGOW_HASKELL__
 #define DEFINE_PATTERN_SYNONYMS 1
 #endif
 
 #ifdef __GLASGOW_HASKELL__
 # define USE_ST_MONAD 1
+#ifndef WORDS_BIGENDIAN
+/*
+ * Unboxed arrays are broken on big-endian architectures.
+ * See https://gitlab.haskell.org/ghc/ghc/-/issues/16998
+ */
 # define USE_UNBOXED_ARRAYS 1
 #endif
+#endif
 
 #endif

contrib/unordered-containers

@@ -0,0 +1,8 @@
+#define PHASE_FUSED [1]
+#define PHASE_INNER [0]
+
+#define INLINE_FUSED INLINE PHASE_FUSED
+#define INLINE_INNER INLINE PHASE_INNER
+
+#define PHASE_STREAM  Please use "PHASE_FUSED" instead
+#define INLINE_STREAM Please use "INLINE_FUSED" instead

contrib/vector

@@ -44,22 +44,9 @@ module Data.Strict.ContainersUtils.Autogen.BitQueue
     , toListQ
     ) where
 
-#if !MIN_VERSION_base(4,8,0)
-import Data.Word (Word)
-#endif
 import Data.Strict.ContainersUtils.Autogen.BitUtil (shiftLL, shiftRL, wordSize)
 import Data.Bits ((.|.), (.&.), testBit)
-#if MIN_VERSION_base(4,8,0)
 import Data.Bits (countTrailingZeros)
-#else
-import Data.Bits (popCount)
-#endif
-
-#if !MIN_VERSION_base(4,8,0)
-countTrailingZeros :: Word -> Int
-countTrailingZeros x = popCount ((x .&. (-x)) - 1)
-{-# INLINE countTrailingZeros #-}
-#endif
 
 -- A bit queue builder. We represent a double word using two words
 -- because we don't currently have access to proper double words.
@@ -109,7 +96,7 @@ buildQ (BQB hi lo) = BQ (BQB hi' lo') where
   lo' = (lo1 `shiftRL` zeros) .|. (hi1 `shiftLL` (wordSize - zeros))
   hi' = hi1 `shiftRL` zeros
 
--- Test if the queue is empty, which occurs when theres
+-- Test if the queue is empty, which occurs when there's
 -- nothing left but a guard bit in the least significant
 -- place.
 nullQ :: BitQueue -> Bool

strict-containers/include/containers.h

@@ -38,23 +38,10 @@ module Data.Strict.ContainersUtils.Autogen.BitUtil
     , wordSize
     ) where
 
-#if !MIN_VERSION_base(4,8,0)
-import Data.Bits ((.|.), xor)
-#endif
 import Data.Bits (popCount, unsafeShiftL, unsafeShiftR
-#if MIN_VERSION_base(4,8,0)
-    , countLeadingZeros
-#endif
+    , countLeadingZeros, finiteBitSize
     )
-#if MIN_VERSION_base(4,7,0)
-import Data.Bits (finiteBitSize)
-#else
-import Data.Bits (bitSize)
-#endif
 
-#if !MIN_VERSION_base (4,8,0)
-import Data.Word (Word)
-#endif
 
 {----------------------------------------------------------------------
   [bitcount] as posted by David F. Place to haskell-cafe on April 11, 2006,
@@ -78,21 +65,7 @@ bitcount a x = a + popCount x
 
 -- | Return a word where only the highest bit is set.
 highestBitMask :: Word -> Word
-#if MIN_VERSION_base(4,8,0)
 highestBitMask w = shiftLL 1 (wordSize - 1 - countLeadingZeros w)
-#else
-highestBitMask x1 = let x2 = x1 .|. x1 `shiftRL` 1
-                        x3 = x2 .|. x2 `shiftRL` 2
-                        x4 = x3 .|. x3 `shiftRL` 4
-                        x5 = x4 .|. x4 `shiftRL` 8
-                        x6 = x5 .|. x5 `shiftRL` 16
-#if !(defined(__GLASGOW_HASKELL__) && WORD_SIZE_IN_BITS==32)
-                        x7 = x6 .|. x6 `shiftRL` 32
-                     in x7 `xor` (x7 `shiftRL` 1)
-#else
-                     in x6 `xor` (x6 `shiftRL` 1)
-#endif
-#endif
 {-# INLINE highestBitMask #-}
 
 -- Right and left logical shifts.
@@ -102,8 +75,4 @@ shiftLL = unsafeShiftL
 
 {-# INLINE wordSize #-}
 wordSize :: Int
-#if MIN_VERSION_base(4,7,0)
 wordSize = finiteBitSize (0 :: Word)
-#else
-wordSize = bitSize (0 :: Word)
-#endif

strict-containers/include/vector.h

@@ -5,12 +5,12 @@
 
 module Data.Strict.ContainersUtils.Autogen.Coercions where
 
-#if __GLASGOW_HASKELL__ >= 708
+#ifdef __GLASGOW_HASKELL__
 import Data.Coerce
 #endif
 
 infixl 8 .#
-#if __GLASGOW_HASKELL__ >= 708
+#ifdef __GLASGOW_HASKELL__
 (.#) :: Coercible b a => (b -> c) -> (a -> b) -> a -> c
 (.#) f _ = coerce f
 #else
@@ -34,7 +34,7 @@ infix 9 .^#
 -- @
 --   foldl f b . fmap g = foldl (f .^# g) b
 -- @
-#if __GLASGOW_HASKELL__ >= 708
+#ifdef __GLASGOW_HASKELL__
 (.^#) :: Coercible c b => (a -> c -> d) -> (b -> c) -> (a -> b -> d)
 (.^#) f _ = coerce f
 #else

strict-containers/src/Data/Strict/ContainersUtils/Autogen/BitQueue.hs

@@ -11,11 +11,7 @@ module Data.Strict.ContainersUtils.Autogen.PtrEquality (ptrEq, hetPtrEq) where
 #ifdef __GLASGOW_HASKELL__
 import GHC.Exts ( reallyUnsafePtrEquality# )
 import Unsafe.Coerce ( unsafeCoerce )
-#if __GLASGOW_HASKELL__ < 707
-import GHC.Exts ( (==#) )
-#else
-import GHC.Exts ( isTrue# )
-#endif
+import GHC.Exts ( Int#, isTrue# )
 #endif
 
 -- | Checks if two pointers are equal. Yes means yes;
@@ -30,13 +26,8 @@ ptrEq :: a -> a -> Bool
 hetPtrEq :: a -> b -> Bool
 
 #ifdef __GLASGOW_HASKELL__
-#if __GLASGOW_HASKELL__ < 707
-ptrEq x y = reallyUnsafePtrEquality# x y ==# 1#
-hetPtrEq x y = unsafeCoerce reallyUnsafePtrEquality# x y ==# 1#
-#else
 ptrEq x y = isTrue# (reallyUnsafePtrEquality# x y)
-hetPtrEq x y = isTrue# (unsafeCoerce reallyUnsafePtrEquality# x y)
-#endif
+hetPtrEq x y = isTrue# (unsafeCoerce (reallyUnsafePtrEquality# :: x -> x -> Int#) x y)
 
 #else
 -- Not GHC

strict-containers/src/Data/Strict/ContainersUtils/Autogen/BitUtil.hs

@@ -5,13 +5,7 @@
 -- | A clone of Control.Monad.State.Strict.
 module Data.Strict.ContainersUtils.Autogen.State where
 
-import Prelude hiding (
-#if MIN_VERSION_base(4,8,0)
-    Applicative
-#endif
-    )
-
-import Control.Monad (ap)
+import Control.Monad (ap, liftM2)
 import Control.Applicative (Applicative(..), liftA)
 
 newtype State s a = State {runState :: s -> (s, a)}
@@ -30,6 +24,11 @@ instance Applicative (State s) where
     {-# INLINE pure #-}
     pure x = State $ \ s -> (s, x)
     (<*>) = ap
+    m *> n = State $ \s -> case runState m s of
+      (s', _) -> runState n s'
+#if MIN_VERSION_base(4,10,0)
+    liftA2 = liftM2
+#endif
 
 execState :: State s a -> s -> a
 execState m x = snd (runState m x)