ghc-prim 0.10.0 → 0.11.0

raw patch · 9 files changed

+770/−234 lines, 9 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• GHC/Classes.hs +30/−23
• GHC/Prim/PtrEq.hs +15/−11
• GHC/PrimopWrappers.hs +114/−75
• GHC/Tuple.hs +1/−1
• GHC/Tuple/Prim.hs +438/−89
• GHC/Types.hs +110/−11
• cbits/atomic.c +4/−22
• changelog.md +48/−0
• ghc-prim.cabal +10/−2

@@ -410,19 +410,7 @@     (C# c1) <= (C# c2) = isTrue# (c1 `leChar#` c2)     (C# c1) <  (C# c2) = isTrue# (c1 `ltChar#` c2) --- | Note that due to the presence of @NaN@, `Float`'s 'Ord' instance does not--- satisfy reflexivity.------ >>> 0/0 <= (0/0 :: Float)--- False------ Also note that, due to the same, `Ord`'s operator interactions are not--- respected by `Float`'s instance:------ >>> (0/0 :: Float) > 1--- False--- >>> compare (0/0 :: Float) 1--- GT+-- | See @instance@ 'Ord' 'Double' for discussion of deviations from IEEE 754 standard. instance Ord Float where     (F# x) `compare` (F# y)         = if      isTrue# (x `ltFloat#` y) then LT@@ -434,19 +422,38 @@     (F# x) >= (F# y) = isTrue# (x `geFloat#` y)     (F# x) >  (F# y) = isTrue# (x `gtFloat#` y) --- | Note that due to the presence of @NaN@, `Double`'s 'Ord' instance does not--- satisfy reflexivity.+-- | IEEE 754 'Double'-precision type includes not only numbers, but also+-- positive and negative infinities and a special element called @NaN@+-- (which can be quiet or signal). ----- >>> 0/0 <= (0/0 :: Double)--- False+-- IEEE 754-2008, section 5.11 requires that if at least one of arguments of+-- '<=', '<', '>', '>=' is @NaN@ then the result of the comparison is 'False',+-- and @instance@ 'Ord' 'Double' complies with this requirement. This violates+-- the reflexivity: both @NaN@ '<=' @NaN@ and @NaN@ '>=' @NaN@ are 'False'. ----- Also note that, due to the same, `Ord`'s operator interactions are not--- respected by `Double`'s instance:+-- IEEE 754-2008, section 5.10 defines @totalOrder@ predicate. Unfortunately,+-- 'compare' on 'Double's violates the IEEE standard and does not define a total order.+-- More specifically, both 'compare' @NaN@ @x@ and 'compare' @x@ @NaN@ always return 'GT'. ----- >>> (0/0 :: Double) > 1--- False--- >>> compare (0/0 :: Double) 1--- GT+-- Thus, users must be extremely cautious when using @instance@ 'Ord' 'Double'.+-- For instance, one should avoid ordered containers with keys represented by 'Double',+-- because data loss and corruption may happen. An IEEE-compliant 'compare' is available+-- in @fp-ieee@ package as @TotallyOrdered@ newtype.+--+-- Moving further, the behaviour of 'min' and 'max' with regards to @NaN@ is+-- also non-compliant. IEEE 754-2008, section 5.3.1 defines that quiet @NaN@+-- should be treated as a missing data by @minNum@ and @maxNum@ functions,+-- for example, @minNum(NaN, 1) = minNum(1, NaN) = 1@. Some languages such as Java+-- deviate from the standard implementing @minNum(NaN, 1) = minNum(1, NaN) = NaN@.+-- However, 'min' / 'max' in @base@ are even worse: 'min' @NaN@ 1 is 1, but 'min' 1 @NaN@+-- is @NaN@.+--+-- IEEE 754-2008 compliant 'min' / 'max' can be found in @ieee754@ package under+-- @minNum@ / @maxNum@ names. Implementations compliant with+-- @minimumNumber@ / @maximumNumber@ from a newer+-- [IEEE 754-2019](https://grouper.ieee.org/groups/msc/ANSI_IEEE-Std-754-2019/background/),+-- section 9.6 are available from @fp-ieee@ package.+-- instance Ord Double where     (D# x) `compare` (D# y)         = if      isTrue# (x <##  y) then LT

@@ -3,6 +3,8 @@ {-# LANGUAGE MagicHash #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE KindSignatures #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE PolyKinds #-}  ----------------------------------------------------------------------------- -- |@@ -38,7 +40,8 @@   ) where  import GHC.Prim-import GHC.Types (UnliftedType) -- Also make implicit dependency known to build system+import GHC.Types -- Also make implicit dependency known to build system+  ( RuntimeRep(BoxedRep), UnliftedType ) default () -- Double and Integer aren't available yet  {- **********************************************************************@@ -91,19 +94,19 @@ --   in primops.txt.pp  -- | Compare the underlying pointers of two arrays.-sameArray# :: Array# a -> Array# a -> Int#+sameArray# :: forall {l} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int# sameArray# = unsafePtrEquality#  -- | Compare the underlying pointers of two mutable arrays.-sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#+sameMutableArray# :: forall {l} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int# sameMutableArray# = unsafePtrEquality#  -- | Compare the underlying pointers of two small arrays.-sameSmallArray# :: SmallArray# a -> SmallArray# a -> Int#+sameSmallArray# :: forall {l} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int# sameSmallArray# = unsafePtrEquality#  -- | Compare the underlying pointers of two small mutable arrays.-sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#+sameSmallMutableArray# :: forall {l} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int# sameSmallMutableArray# = unsafePtrEquality#  -- | Compare the pointers of two byte arrays.@@ -115,23 +118,23 @@ sameMutableByteArray# = unsafePtrEquality#  -- | Compare the underlying pointers of two 'MutVar#'s.-sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#+sameMutVar# :: forall {l} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int# sameMutVar# = unsafePtrEquality#  -- | Compare the underlying pointers of two 'TVar#'s.-sameTVar# :: TVar# s a -> TVar# s a -> Int#+sameTVar# :: forall {l} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int# sameTVar# = unsafePtrEquality#  -- | Compare the underlying pointers of two 'MVar#'s.-sameMVar# :: MVar# s a -> MVar# s a -> Int#+sameMVar# :: forall {l} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int# sameMVar# = unsafePtrEquality#  -- | Compare the underlying pointers of two 'IOPort#'s.-sameIOPort# :: IOPort# s a -> IOPort# s a -> Int#+sameIOPort# :: forall {l} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int# sameIOPort# = unsafePtrEquality#  -- | Compare the underlying pointers of two 'PromptTag#'s.-samePromptTag# :: PromptTag# a -> PromptTag# a -> Int#+samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int# samePromptTag# = unsafePtrEquality#  -- Note [Comparing stable names]@@ -145,5 +148,6 @@ -- does the trick.  -- | Compare two stable names for equality.-eqStableName# :: StableName# a -> StableName# b -> Int#+eqStableName# :: forall {k} {l} (a :: TYPE (BoxedRep k)) (b :: TYPE (BoxedRep l))+              . StableName# a -> StableName# b -> Int# eqStableName# = unsafePtrEquality#

@@ -5,7 +5,7 @@ module GHC.PrimopWrappers where import qualified GHC.Prim import GHC.Tuple ()-import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Int32#, Word32#, Int64#, Word64#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutVar#, RealWorld, PromptTag#, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO)+import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Int32#, Word32#, Int64#, Word64#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, RealWorld, MutVar#, PromptTag#, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO) {-# NOINLINE gtChar# #-} gtChar# :: Char# -> Char# -> Int# gtChar# a1 a2 = GHC.Prim.gtChar# a1 a2@@ -984,6 +984,30 @@ {-# NOINLINE decodeFloat_Int# #-} decodeFloat_Int# :: Float# -> (# Int#,Int# #) decodeFloat_Int# a1 = GHC.Prim.decodeFloat_Int# a1+{-# NOINLINE fmaddFloat# #-}+fmaddFloat# :: Float# -> Float# -> Float# -> Float#+fmaddFloat# a1 a2 a3 = GHC.Prim.fmaddFloat# a1 a2 a3+{-# NOINLINE fmsubFloat# #-}+fmsubFloat# :: Float# -> Float# -> Float# -> Float#+fmsubFloat# a1 a2 a3 = GHC.Prim.fmsubFloat# a1 a2 a3+{-# NOINLINE fnmaddFloat# #-}+fnmaddFloat# :: Float# -> Float# -> Float# -> Float#+fnmaddFloat# a1 a2 a3 = GHC.Prim.fnmaddFloat# a1 a2 a3+{-# NOINLINE fnmsubFloat# #-}+fnmsubFloat# :: Float# -> Float# -> Float# -> Float#+fnmsubFloat# a1 a2 a3 = GHC.Prim.fnmsubFloat# a1 a2 a3+{-# NOINLINE fmaddDouble# #-}+fmaddDouble# :: Double# -> Double# -> Double# -> Double#+fmaddDouble# a1 a2 a3 = GHC.Prim.fmaddDouble# a1 a2 a3+{-# NOINLINE fmsubDouble# #-}+fmsubDouble# :: Double# -> Double# -> Double# -> Double#+fmsubDouble# a1 a2 a3 = GHC.Prim.fmsubDouble# a1 a2 a3+{-# NOINLINE fnmaddDouble# #-}+fnmaddDouble# :: Double# -> Double# -> Double# -> Double#+fnmaddDouble# a1 a2 a3 = GHC.Prim.fnmaddDouble# a1 a2 a3+{-# NOINLINE fnmsubDouble# #-}+fnmsubDouble# :: Double# -> Double# -> Double# -> Double#+fnmsubDouble# a1 a2 a3 = GHC.Prim.fnmsubDouble# a1 a2 a3 {-# NOINLINE newArray# #-} newArray# :: Int# -> v -> State# s -> (# State# s,MutableArray# s v #) newArray# a1 a2 a3 = GHC.Prim.newArray# a1 a2 a3@@ -1146,24 +1170,24 @@ {-# NOINLINE indexInt8Array# #-} indexInt8Array# :: ByteArray# -> Int# -> Int8# indexInt8Array# a1 a2 = GHC.Prim.indexInt8Array# a1 a2-{-# NOINLINE indexInt16Array# #-}-indexInt16Array# :: ByteArray# -> Int# -> Int16#-indexInt16Array# a1 a2 = GHC.Prim.indexInt16Array# a1 a2-{-# NOINLINE indexInt32Array# #-}-indexInt32Array# :: ByteArray# -> Int# -> Int32#-indexInt32Array# a1 a2 = GHC.Prim.indexInt32Array# a1 a2-{-# NOINLINE indexInt64Array# #-}-indexInt64Array# :: ByteArray# -> Int# -> Int64#-indexInt64Array# a1 a2 = GHC.Prim.indexInt64Array# a1 a2 {-# NOINLINE indexWord8Array# #-} indexWord8Array# :: ByteArray# -> Int# -> Word8# indexWord8Array# a1 a2 = GHC.Prim.indexWord8Array# a1 a2+{-# NOINLINE indexInt16Array# #-}+indexInt16Array# :: ByteArray# -> Int# -> Int16#+indexInt16Array# a1 a2 = GHC.Prim.indexInt16Array# a1 a2 {-# NOINLINE indexWord16Array# #-} indexWord16Array# :: ByteArray# -> Int# -> Word16# indexWord16Array# a1 a2 = GHC.Prim.indexWord16Array# a1 a2+{-# NOINLINE indexInt32Array# #-}+indexInt32Array# :: ByteArray# -> Int# -> Int32#+indexInt32Array# a1 a2 = GHC.Prim.indexInt32Array# a1 a2 {-# NOINLINE indexWord32Array# #-} indexWord32Array# :: ByteArray# -> Int# -> Word32# indexWord32Array# a1 a2 = GHC.Prim.indexWord32Array# a1 a2+{-# NOINLINE indexInt64Array# #-}+indexInt64Array# :: ByteArray# -> Int# -> Int64#+indexInt64Array# a1 a2 = GHC.Prim.indexInt64Array# a1 a2 {-# NOINLINE indexWord64Array# #-} indexWord64Array# :: ByteArray# -> Int# -> Word64# indexWord64Array# a1 a2 = GHC.Prim.indexWord64Array# a1 a2@@ -1194,18 +1218,18 @@ {-# NOINLINE indexWord8ArrayAsInt16# #-} indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16# indexWord8ArrayAsInt16# a1 a2 = GHC.Prim.indexWord8ArrayAsInt16# a1 a2-{-# NOINLINE indexWord8ArrayAsInt32# #-}-indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#-indexWord8ArrayAsInt32# a1 a2 = GHC.Prim.indexWord8ArrayAsInt32# a1 a2-{-# NOINLINE indexWord8ArrayAsInt64# #-}-indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#-indexWord8ArrayAsInt64# a1 a2 = GHC.Prim.indexWord8ArrayAsInt64# a1 a2 {-# NOINLINE indexWord8ArrayAsWord16# #-} indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16# indexWord8ArrayAsWord16# a1 a2 = GHC.Prim.indexWord8ArrayAsWord16# a1 a2+{-# NOINLINE indexWord8ArrayAsInt32# #-}+indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#+indexWord8ArrayAsInt32# a1 a2 = GHC.Prim.indexWord8ArrayAsInt32# a1 a2 {-# NOINLINE indexWord8ArrayAsWord32# #-} indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32# indexWord8ArrayAsWord32# a1 a2 = GHC.Prim.indexWord8ArrayAsWord32# a1 a2+{-# NOINLINE indexWord8ArrayAsInt64# #-}+indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#+indexWord8ArrayAsInt64# a1 a2 = GHC.Prim.indexWord8ArrayAsInt64# a1 a2 {-# NOINLINE indexWord8ArrayAsWord64# #-} indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64# indexWord8ArrayAsWord64# a1 a2 = GHC.Prim.indexWord8ArrayAsWord64# a1 a2@@ -1236,24 +1260,24 @@ {-# NOINLINE readInt8Array# #-} readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8# #) readInt8Array# a1 a2 a3 = GHC.Prim.readInt8Array# a1 a2 a3-{-# NOINLINE readInt16Array# #-}-readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #)-readInt16Array# a1 a2 a3 = GHC.Prim.readInt16Array# a1 a2 a3-{-# NOINLINE readInt32Array# #-}-readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)-readInt32Array# a1 a2 a3 = GHC.Prim.readInt32Array# a1 a2 a3-{-# NOINLINE readInt64Array# #-}-readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)-readInt64Array# a1 a2 a3 = GHC.Prim.readInt64Array# a1 a2 a3 {-# NOINLINE readWord8Array# #-} readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8# #) readWord8Array# a1 a2 a3 = GHC.Prim.readWord8Array# a1 a2 a3+{-# NOINLINE readInt16Array# #-}+readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #)+readInt16Array# a1 a2 a3 = GHC.Prim.readInt16Array# a1 a2 a3 {-# NOINLINE readWord16Array# #-} readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #) readWord16Array# a1 a2 a3 = GHC.Prim.readWord16Array# a1 a2 a3+{-# NOINLINE readInt32Array# #-}+readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)+readInt32Array# a1 a2 a3 = GHC.Prim.readInt32Array# a1 a2 a3 {-# NOINLINE readWord32Array# #-} readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #) readWord32Array# a1 a2 a3 = GHC.Prim.readWord32Array# a1 a2 a3+{-# NOINLINE readInt64Array# #-}+readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)+readInt64Array# a1 a2 a3 = GHC.Prim.readInt64Array# a1 a2 a3 {-# NOINLINE readWord64Array# #-} readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #) readWord64Array# a1 a2 a3 = GHC.Prim.readWord64Array# a1 a2 a3@@ -1284,18 +1308,18 @@ {-# NOINLINE readWord8ArrayAsInt16# #-} readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #) readWord8ArrayAsInt16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt16# a1 a2 a3-{-# NOINLINE readWord8ArrayAsInt32# #-}-readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)-readWord8ArrayAsInt32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt32# a1 a2 a3-{-# NOINLINE readWord8ArrayAsInt64# #-}-readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)-readWord8ArrayAsInt64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt64# a1 a2 a3 {-# NOINLINE readWord8ArrayAsWord16# #-} readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #) readWord8ArrayAsWord16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord16# a1 a2 a3+{-# NOINLINE readWord8ArrayAsInt32# #-}+readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)+readWord8ArrayAsInt32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt32# a1 a2 a3 {-# NOINLINE readWord8ArrayAsWord32# #-} readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #) readWord8ArrayAsWord32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord32# a1 a2 a3+{-# NOINLINE readWord8ArrayAsInt64# #-}+readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)+readWord8ArrayAsInt64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt64# a1 a2 a3 {-# NOINLINE readWord8ArrayAsWord64# #-} readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #) readWord8ArrayAsWord64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord64# a1 a2 a3@@ -1326,24 +1350,24 @@ {-# NOINLINE writeInt8Array# #-} writeInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> State# s -> State# s writeInt8Array# a1 a2 a3 a4 = GHC.Prim.writeInt8Array# a1 a2 a3 a4-{-# NOINLINE writeInt16Array# #-}-writeInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s-writeInt16Array# a1 a2 a3 a4 = GHC.Prim.writeInt16Array# a1 a2 a3 a4-{-# NOINLINE writeInt32Array# #-}-writeInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s-writeInt32Array# a1 a2 a3 a4 = GHC.Prim.writeInt32Array# a1 a2 a3 a4-{-# NOINLINE writeInt64Array# #-}-writeInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s-writeInt64Array# a1 a2 a3 a4 = GHC.Prim.writeInt64Array# a1 a2 a3 a4 {-# NOINLINE writeWord8Array# #-} writeWord8Array# :: MutableByteArray# s -> Int# -> Word8# -> State# s -> State# s writeWord8Array# a1 a2 a3 a4 = GHC.Prim.writeWord8Array# a1 a2 a3 a4+{-# NOINLINE writeInt16Array# #-}+writeInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s+writeInt16Array# a1 a2 a3 a4 = GHC.Prim.writeInt16Array# a1 a2 a3 a4 {-# NOINLINE writeWord16Array# #-} writeWord16Array# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s writeWord16Array# a1 a2 a3 a4 = GHC.Prim.writeWord16Array# a1 a2 a3 a4+{-# NOINLINE writeInt32Array# #-}+writeInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s+writeInt32Array# a1 a2 a3 a4 = GHC.Prim.writeInt32Array# a1 a2 a3 a4 {-# NOINLINE writeWord32Array# #-} writeWord32Array# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s writeWord32Array# a1 a2 a3 a4 = GHC.Prim.writeWord32Array# a1 a2 a3 a4+{-# NOINLINE writeInt64Array# #-}+writeInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s+writeInt64Array# a1 a2 a3 a4 = GHC.Prim.writeInt64Array# a1 a2 a3 a4 {-# NOINLINE writeWord64Array# #-} writeWord64Array# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s writeWord64Array# a1 a2 a3 a4 = GHC.Prim.writeWord64Array# a1 a2 a3 a4@@ -1374,18 +1398,18 @@ {-# NOINLINE writeWord8ArrayAsInt16# #-} writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s writeWord8ArrayAsInt16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt16# a1 a2 a3 a4-{-# NOINLINE writeWord8ArrayAsInt32# #-}-writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s-writeWord8ArrayAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt32# a1 a2 a3 a4-{-# NOINLINE writeWord8ArrayAsInt64# #-}-writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s-writeWord8ArrayAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt64# a1 a2 a3 a4 {-# NOINLINE writeWord8ArrayAsWord16# #-} writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s writeWord8ArrayAsWord16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord16# a1 a2 a3 a4+{-# NOINLINE writeWord8ArrayAsInt32# #-}+writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s+writeWord8ArrayAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt32# a1 a2 a3 a4 {-# NOINLINE writeWord8ArrayAsWord32# #-} writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s writeWord8ArrayAsWord32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord32# a1 a2 a3 a4+{-# NOINLINE writeWord8ArrayAsInt64# #-}+writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s+writeWord8ArrayAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt64# a1 a2 a3 a4 {-# NOINLINE writeWord8ArrayAsWord64# #-} writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s writeWord8ArrayAsWord64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord64# a1 a2 a3 a4@@ -1398,6 +1422,9 @@ {-# NOINLINE copyMutableByteArray# #-} copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s copyMutableByteArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableByteArray# a1 a2 a3 a4 a5 a6+{-# NOINLINE copyMutableByteArrayNonOverlapping# #-}+copyMutableByteArrayNonOverlapping# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+copyMutableByteArrayNonOverlapping# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableByteArrayNonOverlapping# a1 a2 a3 a4 a5 a6 {-# NOINLINE copyByteArrayToAddr# #-} copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s copyByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyByteArrayToAddr# a1 a2 a3 a4 a5@@ -1407,9 +1434,18 @@ {-# NOINLINE copyAddrToByteArray# #-} copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s copyAddrToByteArray# a1 a2 a3 a4 a5 = GHC.Prim.copyAddrToByteArray# a1 a2 a3 a4 a5+{-# NOINLINE copyAddrToAddr# #-}+copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# (RealWorld) -> State# (RealWorld)+copyAddrToAddr# a1 a2 a3 a4 = GHC.Prim.copyAddrToAddr# a1 a2 a3 a4+{-# NOINLINE copyAddrToAddrNonOverlapping# #-}+copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# (RealWorld) -> State# (RealWorld)+copyAddrToAddrNonOverlapping# a1 a2 a3 a4 = GHC.Prim.copyAddrToAddrNonOverlapping# a1 a2 a3 a4 {-# NOINLINE setByteArray# #-} setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s setByteArray# a1 a2 a3 a4 a5 = GHC.Prim.setByteArray# a1 a2 a3 a4 a5+{-# NOINLINE setAddrRange# #-}+setAddrRange# :: Addr# -> Int# -> Int# -> State# (RealWorld) -> State# (RealWorld)+setAddrRange# a1 a2 a3 a4 = GHC.Prim.setAddrRange# a1 a2 a3 a4 {-# NOINLINE atomicReadIntArray# #-} atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) atomicReadIntArray# a1 a2 a3 = GHC.Prim.atomicReadIntArray# a1 a2 a3@@ -1509,24 +1545,24 @@ {-# NOINLINE indexInt8OffAddr# #-} indexInt8OffAddr# :: Addr# -> Int# -> Int8# indexInt8OffAddr# a1 a2 = GHC.Prim.indexInt8OffAddr# a1 a2-{-# NOINLINE indexInt16OffAddr# #-}-indexInt16OffAddr# :: Addr# -> Int# -> Int16#-indexInt16OffAddr# a1 a2 = GHC.Prim.indexInt16OffAddr# a1 a2-{-# NOINLINE indexInt32OffAddr# #-}-indexInt32OffAddr# :: Addr# -> Int# -> Int32#-indexInt32OffAddr# a1 a2 = GHC.Prim.indexInt32OffAddr# a1 a2-{-# NOINLINE indexInt64OffAddr# #-}-indexInt64OffAddr# :: Addr# -> Int# -> Int64#-indexInt64OffAddr# a1 a2 = GHC.Prim.indexInt64OffAddr# a1 a2 {-# NOINLINE indexWord8OffAddr# #-} indexWord8OffAddr# :: Addr# -> Int# -> Word8# indexWord8OffAddr# a1 a2 = GHC.Prim.indexWord8OffAddr# a1 a2+{-# NOINLINE indexInt16OffAddr# #-}+indexInt16OffAddr# :: Addr# -> Int# -> Int16#+indexInt16OffAddr# a1 a2 = GHC.Prim.indexInt16OffAddr# a1 a2 {-# NOINLINE indexWord16OffAddr# #-} indexWord16OffAddr# :: Addr# -> Int# -> Word16# indexWord16OffAddr# a1 a2 = GHC.Prim.indexWord16OffAddr# a1 a2+{-# NOINLINE indexInt32OffAddr# #-}+indexInt32OffAddr# :: Addr# -> Int# -> Int32#+indexInt32OffAddr# a1 a2 = GHC.Prim.indexInt32OffAddr# a1 a2 {-# NOINLINE indexWord32OffAddr# #-} indexWord32OffAddr# :: Addr# -> Int# -> Word32# indexWord32OffAddr# a1 a2 = GHC.Prim.indexWord32OffAddr# a1 a2+{-# NOINLINE indexInt64OffAddr# #-}+indexInt64OffAddr# :: Addr# -> Int# -> Int64#+indexInt64OffAddr# a1 a2 = GHC.Prim.indexInt64OffAddr# a1 a2 {-# NOINLINE indexWord64OffAddr# #-} indexWord64OffAddr# :: Addr# -> Int# -> Word64# indexWord64OffAddr# a1 a2 = GHC.Prim.indexWord64OffAddr# a1 a2@@ -1557,24 +1593,24 @@ {-# NOINLINE readInt8OffAddr# #-} readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8# #) readInt8OffAddr# a1 a2 a3 = GHC.Prim.readInt8OffAddr# a1 a2 a3-{-# NOINLINE readInt16OffAddr# #-}-readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #)-readInt16OffAddr# a1 a2 a3 = GHC.Prim.readInt16OffAddr# a1 a2 a3-{-# NOINLINE readInt32OffAddr# #-}-readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #)-readInt32OffAddr# a1 a2 a3 = GHC.Prim.readInt32OffAddr# a1 a2 a3-{-# NOINLINE readInt64OffAddr# #-}-readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #)-readInt64OffAddr# a1 a2 a3 = GHC.Prim.readInt64OffAddr# a1 a2 a3 {-# NOINLINE readWord8OffAddr# #-} readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8# #) readWord8OffAddr# a1 a2 a3 = GHC.Prim.readWord8OffAddr# a1 a2 a3+{-# NOINLINE readInt16OffAddr# #-}+readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #)+readInt16OffAddr# a1 a2 a3 = GHC.Prim.readInt16OffAddr# a1 a2 a3 {-# NOINLINE readWord16OffAddr# #-} readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #) readWord16OffAddr# a1 a2 a3 = GHC.Prim.readWord16OffAddr# a1 a2 a3+{-# NOINLINE readInt32OffAddr# #-}+readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #)+readInt32OffAddr# a1 a2 a3 = GHC.Prim.readInt32OffAddr# a1 a2 a3 {-# NOINLINE readWord32OffAddr# #-} readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #) readWord32OffAddr# a1 a2 a3 = GHC.Prim.readWord32OffAddr# a1 a2 a3+{-# NOINLINE readInt64OffAddr# #-}+readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #)+readInt64OffAddr# a1 a2 a3 = GHC.Prim.readInt64OffAddr# a1 a2 a3 {-# NOINLINE readWord64OffAddr# #-} readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64# #) readWord64OffAddr# a1 a2 a3 = GHC.Prim.readWord64OffAddr# a1 a2 a3@@ -1605,24 +1641,24 @@ {-# NOINLINE writeInt8OffAddr# #-} writeInt8OffAddr# :: Addr# -> Int# -> Int8# -> State# s -> State# s writeInt8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt8OffAddr# a1 a2 a3 a4-{-# NOINLINE writeInt16OffAddr# #-}-writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# s -> State# s-writeInt16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt16OffAddr# a1 a2 a3 a4-{-# NOINLINE writeInt32OffAddr# #-}-writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# s -> State# s-writeInt32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt32OffAddr# a1 a2 a3 a4-{-# NOINLINE writeInt64OffAddr# #-}-writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# s -> State# s-writeInt64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt64OffAddr# a1 a2 a3 a4 {-# NOINLINE writeWord8OffAddr# #-} writeWord8OffAddr# :: Addr# -> Int# -> Word8# -> State# s -> State# s writeWord8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddr# a1 a2 a3 a4+{-# NOINLINE writeInt16OffAddr# #-}+writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# s -> State# s+writeInt16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt16OffAddr# a1 a2 a3 a4 {-# NOINLINE writeWord16OffAddr# #-} writeWord16OffAddr# :: Addr# -> Int# -> Word16# -> State# s -> State# s writeWord16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord16OffAddr# a1 a2 a3 a4+{-# NOINLINE writeInt32OffAddr# #-}+writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# s -> State# s+writeInt32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt32OffAddr# a1 a2 a3 a4 {-# NOINLINE writeWord32OffAddr# #-} writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> State# s -> State# s writeWord32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord32OffAddr# a1 a2 a3 a4+{-# NOINLINE writeInt64OffAddr# #-}+writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# s -> State# s+writeInt64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt64OffAddr# a1 a2 a3 a4 {-# NOINLINE writeWord64OffAddr# #-} writeWord64OffAddr# :: Addr# -> Int# -> Word64# -> State# s -> State# s writeWord64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord64OffAddr# a1 a2 a3 a4@@ -1683,6 +1719,9 @@ {-# NOINLINE writeMutVar# #-} writeMutVar# :: MutVar# s v -> v -> State# s -> State# s writeMutVar# a1 a2 a3 = GHC.Prim.writeMutVar# a1 a2 a3+{-# NOINLINE atomicSwapMutVar# #-}+atomicSwapMutVar# :: MutVar# s v -> v -> State# s -> (# State# s,v #)+atomicSwapMutVar# a1 a2 a3 = GHC.Prim.atomicSwapMutVar# a1 a2 a3 {-# NOINLINE atomicModifyMutVar2# #-} atomicModifyMutVar2# :: MutVar# s a -> (a -> c) -> State# s -> (# State# s,a,c #) atomicModifyMutVar2# a1 a2 a3 = GHC.Prim.atomicModifyMutVar2# a1 a2 a3@@ -1846,7 +1885,7 @@ finalizeWeak# :: Weak# v -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #) finalizeWeak# a1 a2 = GHC.Prim.finalizeWeak# a1 a2 {-# NOINLINE touch# #-}-touch# :: v -> State# (RealWorld) -> State# (RealWorld)+touch# :: v -> State# s -> State# s touch# a1 a2 = GHC.Prim.touch# a1 a2 {-# NOINLINE makeStablePtr# #-} makeStablePtr# :: v -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# v #)@@ -1915,7 +1954,7 @@ numSparks# :: State# s -> (# State# s,Int# #) numSparks# a1 = GHC.Prim.numSparks# a1 {-# NOINLINE keepAlive# #-}-keepAlive# :: v -> State# (RealWorld) -> (State# (RealWorld) -> p) -> p+keepAlive# :: v -> State# s -> (State# s -> p) -> p keepAlive# a1 a2 a3 = GHC.Prim.keepAlive# a1 a2 a3 {-# NOINLINE dataToTag# #-} dataToTag# :: a -> Int#

@@ -5,7 +5,7 @@ -- Module      :  GHC.Tuple -- Copyright   :  (c) The University of Glasgow 2001 -- License     :  BSD-style (see the file libraries/ghc-prim/LICENSE)--- +-- -- Maintainer  :  libraries@haskell.org -- Stability   :  experimental -- Portability :  non-portable (GHC extensions)

@@ -22,16 +22,19 @@  default () -- Double and Integer aren't available yet --- | The unit datatype @()@ has one non-undefined member, the nullary+-- | The unit datatype @Unit@ has one non-undefined member, the nullary -- constructor @()@.-data () = ()+--+-- @since 0.11.0+--+data Unit = ()  -- The desugarer uses 1-tuples,--- but "()" is already used up for 0-tuples+-- but "Unit" is already used up for 0-tuples -- See Note [One-tuples] in GHC.Builtin.Types --- | @Solo@ is the canonical lifted 1-tuple, just like '(,)' is the canonical--- lifted 2-tuple (pair) and '(,,)' is the canonical lifted 3-tuple (triple).+-- | @Solo@ is the canonical lifted 1-tuple, just like 'Tuple2' is the canonical+-- lifted 2-tuple (pair) and 'Tuple3' is the canonical lifted 3-tuple (triple). -- -- The most important feature of @Solo@ is that it is possible to force its -- "outside" (usually by pattern matching) without forcing its "inside",@@ -79,6 +82,26 @@ -- implementations of lazy and strict mapping functions. data Solo a = MkSolo a +-- | Extract the value from a 'Solo'. Very often, values should be extracted+-- directly using pattern matching, to control just what gets evaluated when.+-- @getSolo@ is for convenience in situations where that is not the case:+--+-- When the result is passed to a /strict/ function, it makes no difference+-- whether the pattern matching is done on the \"outside\" or on the+-- \"inside\":+--+-- @+-- Data.Set.insert (getSolo sol) set === case sol of Solo v -> Data.Set.insert v set+-- @+--+-- A traversal may be performed in 'Solo' in order to control evaluation+-- internally, while using @getSolo@ to extract the final result. A strict+-- mapping function, for example, could be defined+--+-- @+-- map' :: Traversable t => (a -> b) -> t a -> t b+-- map' f = getSolo . traverse ((Solo $!) . f)+-- @ getSolo :: Solo a -> a -- getSolo is a standalone function, rather than a record field of Solo, -- because Solo is a wired-in TyCon, and a wired-in TyCon that  has@@ -87,146 +110,472 @@ -- to have getSolo as its own separate function (#20562) getSolo (MkSolo a) = a -data (a,b) = (a,b)-data (a,b,c) = (a,b,c)-data (a,b,c,d) = (a,b,c,d)-data (a,b,c,d,e) = (a,b,c,d,e)-data (a,b,c,d,e,f) = (a,b,c,d,e,f)-data (a,b,c,d,e,f,g) = (a,b,c,d,e,f,g)-data (a,b,c,d,e,f,g,h) = (a,b,c,d,e,f,g,h)-data (a,b,c,d,e,f,g,h,i) = (a,b,c,d,e,f,g,h,i)-data (a,b,c,d,e,f,g,h,i,j) = (a,b,c,d,e,f,g,h,i,j)-data (a,b,c,d,e,f,g,h,i,j,k) = (a,b,c,d,e,f,g,h,i,j,k)-data (a,b,c,d,e,f,g,h,i,j,k,l) = (a,b,c,d,e,f,g,h,i,j,k,l)-data (a,b,c,d,e,f,g,h,i,j,k,l,m) = (a,b,c,d,e,f,g,h,i,j,k,l,m)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z)+-- | A tuple of zero elements, a synonym for 'Unit'.+--+-- @since 0.11.0+--+type Tuple0 = Unit -data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1)+-- | A tuple of one element, a synonym for 'Solo'.+--+-- @since 0.11.0+--+type Tuple1 = Solo++-- | A tuple of two elements.+--+-- @since 0.11.0+--+data Tuple2 a b = (a,b)++-- | A tuple of three elements.+--+-- @since 0.11.0+--+data Tuple3 a b c = (a,b,c)++-- | A tuple of four elements.+--+-- @since 0.11.0+--+data Tuple4 a b c d = (a,b,c,d)++-- | A tuple of five elements.+--+-- @since 0.11.0+--+data Tuple5 a b c d e = (a,b,c,d,e)++-- | A tuple of six elements.+--+-- @since 0.11.0+--+data Tuple6 a b c d e f = (a,b,c,d,e,f)++-- | A tuple of seven elements.+--+-- @since 0.11.0+--+data Tuple7 a b c d e f g = (a,b,c,d,e,f,g)++-- | A tuple of eight elements.+--+-- @since 0.11.0+--+data Tuple8 a b c d e f g h = (a,b,c,d,e,f,g,h)++-- | A tuple of nine elements.+--+-- @since 0.11.0+--+data Tuple9 a b c d e f g h i = (a,b,c,d,e,f,g,h,i)++-- | A tuple of ten elements.+--+-- @since 0.11.0+--+data Tuple10 a b c d e f g h i j = (a,b,c,d,e,f,g,h,i,j)++-- | A tuple of eleven elements.+--+-- @since 0.11.0+--+data Tuple11 a b c d e f g h i j k = (a,b,c,d,e,f,g,h,i,j,k)++-- | A tuple of twelve elements.+--+-- @since 0.11.0+--+data Tuple12 a b c d e f g h i j k l = (a,b,c,d,e,f,g,h,i,j,k,l)++-- | A tuple of 13 elements.+--+-- @since 0.11.0+--+data Tuple13 a b c d e f g h i j k l m = (a,b,c,d,e,f,g,h,i,j,k,l,m)++-- | A tuple of 14 elements.+--+-- @since 0.11.0+--+data Tuple14 a b c d e f g h i j k l m n = (a,b,c,d,e,f,g,h,i,j,k,l,m,n)++-- | A tuple of 15 elements.+--+-- @since 0.11.0+--+data Tuple15 a b c d e f g h i j k l m n o = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)++-- | A tuple of 16 elements.+--+-- @since 0.11.0+--+data Tuple16 a b c d e f g h i j k l m n o p = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)++-- | A tuple of 17 elements.+--+-- @since 0.11.0+--+data Tuple17 a b c d e f g h i j k l m n o p q = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)++-- | A tuple of 18 elements.+--+-- @since 0.11.0+--+data Tuple18 a b c d e f g h i j k l m n o p q r = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)++-- | A tuple of 19 elements.+--+-- @since 0.11.0+--+data Tuple19 a b c d e f g h i j k l m n o p q r s = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)++-- | A tuple of 20 elements.+--+-- @since 0.11.0+--+data Tuple20 a b c d e f g h i j k l m n o p q r s t = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)++-- | A tuple of 21 elements.++--+-- @since 0.11.0+--+data Tuple21 a b c d e f g h i j k l m n o p q r s t u = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u)++-- | A tuple of 22 elements.+--+-- @since 0.11.0+--+data Tuple22 a b c d e f g h i j k l m n o p q r s t u v = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v)++-- | A tuple of 23 elements.+--+-- @since 0.11.0+--+data Tuple23 a b c d e f g h i j k l m n o p q r s t u v w = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w)++-- | A tuple of 24 elements.+--+-- @since 0.11.0+--+data Tuple24 a b c d e f g h i j k l m n o p q r s t u v w x = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x)++-- | A tuple of 25 elements.+--+-- @since 0.11.0+--+data Tuple25 a b c d e f g h i j k l m n o p q r s t u v w x y = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y)++-- | A tuple of 26 elements.+--+-- @since 0.11.0+--+data Tuple26 a b c d e f g h i j k l m n o p q r s t u v w x y z = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z)++-- | A tuple of 27 elements.+--+-- @since 0.11.0+--+data Tuple27 a b c d e f g h i j k l m n o p q r s t u v w x y z a1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1)++-- | A tuple of 28 elements.+--+-- @since 0.11.0+--+data Tuple28 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1)++-- | A tuple of 29 elements.+--+-- @since 0.11.0+--+data Tuple29 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1)++-- | A tuple of 30 elements.+--+-- @since 0.11.0+--+data Tuple30 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1)++-- | A tuple of 31 elements.+--+-- @since 0.11.0+--+data Tuple31 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1)++-- | A tuple of 32 elements.+--+-- @since 0.11.0+--+data Tuple32 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1)++-- | A tuple of 33 elements.+--+-- @since 0.11.0+--+data Tuple33 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1)++-- | A tuple of 34 elements.+--+-- @since 0.11.0+--+data Tuple34 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1)++-- | A tuple of 35 elements.+--+-- @since 0.11.0+--+data Tuple35 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1)++-- | A tuple of 36 elements.+--+-- @since 0.11.0+--+data Tuple36 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1)++-- | A tuple of 37 elements.+--+-- @since 0.11.0+--+data Tuple37 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1)++-- | A tuple of 38 elements.+--+-- @since 0.11.0+--+data Tuple38 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1)++-- | A tuple of 39 elements.+--+-- @since 0.11.0+--+data Tuple39 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1)++-- | A tuple of 40 elements.+--+-- @since 0.11.0+--+data Tuple40 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1)++-- | A tuple of 41 elements.+--+-- @since 0.11.0+--+data Tuple41 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1)++-- | A tuple of 42 elements.+--+-- @since 0.11.0+--+data Tuple42 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1)++-- | A tuple of 43 elements.+--+-- @since 0.11.0+--+data Tuple43 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1)++-- | A tuple of 44 elements.+--+-- @since 0.11.0+--+data Tuple44 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1)++-- | A tuple of 45 elements.+--+-- @since 0.11.0+--+data Tuple45 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1)++-- | A tuple of 46 elements.+--+-- @since 0.11.0+--+data Tuple46 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1)++-- | A tuple of 47 elements.+--+-- @since 0.11.0+--+data Tuple47 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1)++-- | A tuple of 48 elements.+--+-- @since 0.11.0+--+data Tuple48 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1)++-- | A tuple of 49 elements.+--+-- @since 0.11.0+--+data Tuple49 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1)++-- | A tuple of 50 elements.+--+-- @since 0.11.0+--+data Tuple50 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1)++-- | A tuple of 51 elements.+--+-- @since 0.11.0+--+data Tuple51 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1)++-- | A tuple of 52 elements.+--+-- @since 0.11.0+--+data Tuple52 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2)++-- | A tuple of 53 elements.+--+-- @since 0.11.0+--+data Tuple53 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2)++-- | A tuple of 54 elements.+--+-- @since 0.11.0+--+data Tuple54 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2)++-- | A tuple of 55 elements.+--+-- @since 0.11.0+--+data Tuple55 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2)++-- | A tuple of 56 elements.+--+-- @since 0.11.0+--+data Tuple56 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2)++-- | A tuple of 57 elements.+--+-- @since 0.11.0+--+data Tuple57 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2)++-- | A tuple of 58 elements.+--+-- @since 0.11.0+--+data Tuple58 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2)++-- | A tuple of 59 elements.+--+-- @since 0.11.0+--+data Tuple59 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2)++-- | A tuple of 60 elements.+--+-- @since 0.11.0+--+data Tuple60 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2)++-- | A tuple of 61 elements.+--+-- @since 0.11.0+--+data Tuple61 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2)++-- | A tuple of 62 elements.+--+-- @since 0.11.0+--+data Tuple62 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2)++-- | A tuple of 63 elements.+--+-- @since 0.11.0+--+data Tuple63 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2)-data (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,-      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2)++-- | A tuple of 64 elements.+--+-- @since 0.11.0+--+data Tuple64 a b c d e f g h i j k l m n o p q r s t u v w x y z a1 b1 c1 d1 e1 f1 g1 h1 i1 j1 k1 l1 m1 n1 o1 p1 q1+      r1 s1 t1 u1 v1 w1 x1 y1 z1 a2 b2 c2 d2 e2 f2 g2 h2 i2 j2 k2 l2   = (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,      r1,s1,t1,u1,v1,w1,x1,y1,z1,a2,b2,c2,d2,e2,f2,g2,h2,i2,j2,k2,l2)

@@ -184,6 +184,8 @@ -- >>> ['h','e','l','l','o'] == "hello" -- True --+-- @since 0.10.0+-- data List a = [] | a : List a  @@ -202,17 +204,96 @@ *                                                                      * ********************************************************************* -} -{- | The character type 'Char' is an enumeration whose values represent-Unicode (or equivalently ISO\/IEC 10646) code points (i.e. characters, see-<http://www.unicode.org/> for details).  This set extends the ISO 8859-1-(Latin-1) character set (the first 256 characters), which is itself an extension-of the ASCII character set (the first 128 characters).  A character literal in-Haskell has type 'Char'.+{- | The character type 'Char' represents Unicode codespace+and its elements are code points as in definitions+[D9 and D10 of the Unicode Standard](https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf#G2212). -To convert a 'Char' to or from the corresponding 'Int' value defined-by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the-'Prelude.Enum' class respectively (or equivalently 'Data.Char.ord' and-'Data.Char.chr').+Character literals in Haskell are single-quoted: @\'Q\'@, @\'Я\'@ or @\'Ω\'@.+To represent a single quote itself use @\'\\''@, and to represent a backslash+use @\'\\\\\'@. The full grammar can be found in the section 2.6 of the+[Haskell 2010 Language Report](https://www.haskell.org/definition/haskell2010.pdf#section.2.6).++To specify a character by its code point one can use decimal, hexadecimal+or octal notation: @\'\\65\'@, @\'\\x41\'@ and @\'\\o101\'@ are all alternative forms+of @\'A\'@. The largest code point is @\'\\x10ffff\'@.++There is a special escape syntax for ASCII control characters:+++-------------+-------------------+---------------------------++| Escape      | Alternatives      | Meaning                   |++=============+===================+===========================++| @'\\NUL'@   | @'\\0'@           | null character            |++-------------+-------------------+---------------------------++| @'\\SOH'@   | @'\\1'@           | start of heading          |++-------------+-------------------+---------------------------++| @'\\STX'@   | @'\\2'@           | start of text             |++-------------+-------------------+---------------------------++| @'\\ETX'@   | @'\\3'@           | end of text               |++-------------+-------------------+---------------------------++| @'\\EOT'@   | @'\\4'@           | end of transmission       |++-------------+-------------------+---------------------------++| @'\\ENQ'@   | @'\\5'@           | enquiry                   |++-------------+-------------------+---------------------------++| @'\\ACK'@   | @'\\6'@           | acknowledge               |++-------------+-------------------+---------------------------++| @'\\BEL'@   | @'\\7'@, @'\\a'@  | bell (alert)              |++-------------+-------------------+---------------------------++| @'\\BS'@    | @'\\8'@, @'\\b'@  | backspace                 |++-------------+-------------------+---------------------------++| @'\\HT'@    | @'\\9'@, @'\\t'@  | horizontal tab            |++-------------+-------------------+---------------------------++| @'\\LF'@    | @'\\10'@, @'\\n'@ | line feed (new line)      |++-------------+-------------------+---------------------------++| @'\\VT'@    | @'\\11'@, @'\\v'@ | vertical tab              |++-------------+-------------------+---------------------------++| @'\\FF'@    | @'\\12'@, @'\\f'@ | form feed                 |++-------------+-------------------+---------------------------++| @'\\CR'@    | @'\\13'@, @'\\r'@ | carriage return           |++-------------+-------------------+---------------------------++| @'\\SO'@    | @'\\14'@          | shift out                 |++-------------+-------------------+---------------------------++| @'\\SI'@    | @'\\15'@          | shift in                  |++-------------+-------------------+---------------------------++| @'\\DLE'@   | @'\\16'@          | data link escape          |++-------------+-------------------+---------------------------++| @'\\DC1'@   | @'\\17'@          | device control 1          |++-------------+-------------------+---------------------------++| @'\\DC2'@   | @'\\18'@          | device control 2          |++-------------+-------------------+---------------------------++| @'\\DC3'@   | @'\\19'@          | device control 3          |++-------------+-------------------+---------------------------++| @'\\DC4'@   | @'\\20'@          | device control 4          |++-------------+-------------------+---------------------------++| @'\\NAK'@   | @'\\21'@          | negative acknowledge      |++-------------+-------------------+---------------------------++| @'\\SYN'@   | @'\\22'@          | synchronous idle          |++-------------+-------------------+---------------------------++| @'\\ETB'@   | @'\\23'@          | end of transmission block |++-------------+-------------------+---------------------------++| @'\\CAN'@   | @'\\24'@          | cancel                    |++-------------+-------------------+---------------------------++| @'\\EM'@    | @'\\25'@          | end of medium             |++-------------+-------------------+---------------------------++| @'\\SUB'@   | @'\\26'@          | substitute                |++-------------+-------------------+---------------------------++| @'\\ESC'@   | @'\\27'@          | escape                    |++-------------+-------------------+---------------------------++| @'\\FS'@    | @'\\28'@          | file separator            |++-------------+-------------------+---------------------------++| @'\\GS'@    | @'\\29'@          | group separator           |++-------------+-------------------+---------------------------++| @'\\RS'@    | @'\\30'@          | record separator          |++-------------+-------------------+---------------------------++| @'\\US'@    | @'\\31'@          | unit separator            |++-------------+-------------------+---------------------------++| @'\\SP'@    | @'\\32'@, @' '@   | space                     |++-------------+-------------------+---------------------------++| @'\\DEL'@   | @'\\127'@         | delete                    |++-------------+-------------------+---------------------------+++[Data.Char](https://hackage.haskell.org/package/base/docs/Data-Char.html)+provides utilities to work with 'Char'.+ -} data {-# CTYPE "HsChar" #-} Char = C# Char# @@ -435,7 +516,25 @@ -- specializations. However, not all loops fall into this category. -- -- Libraries can specify this by using 'SPEC' data type to inform which--- loops should be aggressively specialized.+-- loops should be aggressively specialized. For example,+-- instead of+--+-- > loop x where loop arg = ...+--+-- write+--+-- > loop SPEC x where loop !_ arg = ...+--+-- There is no semantic difference between 'SPEC' and 'SPEC2',+-- we just need a type with two contructors lest it is optimised away+-- before @SpecConstr@.+--+-- This type is reexported from "GHC.Exts" since GHC 9.0 and @base-4.15@.+-- For compatibility with earlier releases import it from "GHC.Types"+-- in @ghc-prim@ package.+--+-- @since 0.3.1.0+-- data SPEC = SPEC | SPEC2  

@@ -33,14 +33,12 @@   return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_add64(StgWord x, StgWord64 val); StgWord64 hs_atomic_add64(StgWord x, StgWord64 val) {   return __sync_fetch_and_add((volatile StgWord64 *) x, val); }-#endif  // FetchSubByteArrayOp_Int @@ -65,14 +63,12 @@   return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val); StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val) {   return __sync_fetch_and_sub((volatile StgWord64 *) x, val); }-#endif  // FetchAndByteArrayOp_Int @@ -97,14 +93,12 @@   return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_and64(StgWord x, StgWord64 val); StgWord64 hs_atomic_and64(StgWord x, StgWord64 val) {   return __sync_fetch_and_and((volatile StgWord64 *) x, val); }-#endif  // FetchNandByteArrayOp_Int @@ -206,7 +200,6 @@ #endif } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val); StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val)@@ -217,7 +210,6 @@   CAS_NAND((volatile StgWord64 *) x, val); #endif }-#endif  #pragma GCC diagnostic pop @@ -244,14 +236,12 @@   return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_or64(StgWord x, StgWord64 val); StgWord64 hs_atomic_or64(StgWord x, StgWord64 val) {   return __sync_fetch_and_or((volatile StgWord64 *) x, val); }-#endif  // FetchXorByteArrayOp_Int @@ -276,14 +266,12 @@   return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val); } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val); StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val) {   return __sync_fetch_and_xor((volatile StgWord64 *) x, val); }-#endif  // CasByteArrayOp_Int @@ -338,15 +326,13 @@   return (StgWord) __atomic_exchange_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST); } -#if WORD_SIZE_IN_BITS == 64 //GCC provides this even on 32bit, but StgWord is still 32 bits.-extern StgWord hs_xchg64(StgWord x, StgWord val);-StgWord-hs_xchg64(StgWord x, StgWord val)+extern StgWord64 hs_xchg64(StgWord x, StgWord64 val);+StgWord64+hs_xchg64(StgWord x, StgWord64 val) {-  return (StgWord) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST);+  return (StgWord64) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST); }-#endif  // AtomicReadByteArrayOp_Int // Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp)@@ -391,7 +377,6 @@ #endif } -#if WORD_SIZE_IN_BITS == 64 extern StgWord64 hs_atomicread64(StgWord x); StgWord64 hs_atomicread64(StgWord x)@@ -402,7 +387,6 @@   return __sync_add_and_fetch((StgWord64 *) x, 0); #endif }-#endif  // AtomicWriteByteArrayOp_Int // Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp)@@ -441,7 +425,6 @@ #endif } -#if WORD_SIZE_IN_BITS == 64 extern void hs_atomicwrite64(StgWord x, StgWord64 val); void hs_atomicwrite64(StgWord x, StgWord64 val)@@ -452,6 +435,5 @@   while (!__sync_bool_compare_and_swap((StgWord64 *) x, *(StgWord64 *) x, (StgWord64) val)); #endif }-#endif  #endif

@@ -1,3 +1,49 @@+## 0.11.0++- Shipped with GHC 9.8.1++- Primitive pointer comparison functions are now levity-polymorphic, e.g.++  ```haskell+  sameArray# :: forall {l} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#+  ```++  This change affects the following functions:+    - `sameArray#`, `sameMutableArray#`,+    - `sameSmallArray#`, `sameSmallMutableArray#`,+    - `sameMutVar#`, `sameTVar#`, `sameMVar#`+    - `sameIOPort#`, `eqStableName#`.++- `keepAlive#` and `touch#` are now polymorphic in their state token (#23163; [CLC#152](https://github.com/haskell/core-libraries-committee/issues/152))++- Several new primops were added:++  - `copyMutableByteArrayNonOverlapping#`+  - `copyAddrToAddr#`+  - `copyAddrToAddrNonOverlapping#`+  - `setAddrRange#`++- New primops for fused multiply-add operations. These primops combine a+  multiplication and an addition, compiling to a single instruction when+  the `-mfma` flag is enabled and the architecture supports it.++  The new primops are `fmaddFloat#, fmsubFloat#, fnmaddFloat#, fnmsubFloat# :: Float# -> Float# -> Float# -> Float#`+  and `fmaddDouble#, fmsubDouble#, fnmaddDouble#, fnmsubDouble# :: Double# -> Double# -> Double# -> Double#`.++  These implement the following operations, while performing one single+  rounding at the end, leading to a more accurate result:++    - `fmaddFloat# x y z`, `fmaddDouble# x y z` compute `x * y + z`.+    - `fmsubFloat# x y z`, `fmsubDouble# x y z` compute `x * y - z`.+    - `fnmaddFloat# x y z`, `fnmaddDouble# x y z` compute `- x * y + z`.+    - `fnmsubFloat# x y z`, `fnmsubDouble# x y z` compute `- x * y - z`.++  Warning: on unsupported architectures, the software emulation provided by+  the fallback to the C standard library is not guaranteed to be IEEE-compliant.++- `Unit`, `Tuple0`, `Tuple1`, `Tuple2`, `Tuple3` and so on (up to `Tuple64`)+  are now exported from `GHC.Tuple.Prim` and reexported from `GHC.Tuple`.+ ## 0.10.0  - Shipped with GHC 9.6.1@@ -27,6 +73,8 @@   with compact regions.   We are working on ways to allow users and library authors to get back the   performance benefits of the old behaviour where possible.++- `List` is now exported from `GHC.Types`.  ## 0.9.0 *August 2022* 

@@ -1,6 +1,6 @@ cabal-version:  2.2 name:           ghc-prim-version:        0.10.0+version:        0.11.0 -- NOTE: Don't forget to update ./changelog.md license:        BSD-3-Clause license-file:   LICENSE@@ -27,6 +27,9 @@ custom-setup     setup-depends: base >= 4 && < 5, process, filepath, directory, Cabal >= 1.23 && < 3.9 +flag need-atomic+  default: False+ Library     default-language: Haskell2010     other-extensions:@@ -68,17 +71,22 @@         -- is no longer re-exporting them (see #11223)         -- ucrt: standard C library. The RTS will automatically include this,         --       but is added for completeness.+        -- mingwex: provides GNU POSIX extensions that aren't provided by ucrt.         -- mingw32: Unfortunately required because of a resource leak between         --          mingwex and mingw32. the __math_err symbol is defined in         --          mingw32 which is required by mingwex.         -- user32: provides access to apis to modify user components (UI etc)         --         on Windows. Required because of mingw32.-        extra-libraries: user32, mingw32, ucrt+        extra-libraries: user32, mingw32, mingwex, ucrt      if os(linux)         -- we need libm, but for musl and other's we might need libc, as libm         -- is just an empty shell.         extra-libraries: c, m++    if flag(need-atomic)+        -- for 64-bit atomic ops on armel (#20549)+        extra-libraries: atomic      if !os(ghcjs)       c-sources: