diff --git a/GHC/Classes.hs b/GHC/Classes.hs
--- a/GHC/Classes.hs
+++ b/GHC/Classes.hs
@@ -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
diff --git a/GHC/Prim/PtrEq.hs b/GHC/Prim/PtrEq.hs
--- a/GHC/Prim/PtrEq.hs
+++ b/GHC/Prim/PtrEq.hs
@@ -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#
diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs
--- a/GHC/PrimopWrappers.hs
+++ b/GHC/PrimopWrappers.hs
@@ -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#
diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs
--- a/GHC/Tuple.hs
+++ b/GHC/Tuple.hs
@@ -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)
diff --git a/GHC/Tuple/Prim.hs b/GHC/Tuple/Prim.hs
--- a/GHC/Tuple/Prim.hs
+++ b/GHC/Tuple/Prim.hs
@@ -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)
diff --git a/GHC/Types.hs b/GHC/Types.hs
--- a/GHC/Types.hs
+++ b/GHC/Types.hs
@@ -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
 
 
diff --git a/cbits/atomic.c b/cbits/atomic.c
--- a/cbits/atomic.c
+++ b/cbits/atomic.c
@@ -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
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -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*
 
diff --git a/ghc-prim.cabal b/ghc-prim.cabal
--- a/ghc-prim.cabal
+++ b/ghc-prim.cabal
@@ -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: