diff --git a/GHC/CString.hs b/GHC/CString.hs
--- a/GHC/CString.hs
+++ b/GHC/CString.hs
@@ -225,7 +225,6 @@
         -- See Note [unpackCString# iterating over addr]
         !ch = indexCharOffAddr# addr 0#
 
-
 unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char]
 {-# NOINLINE unpackAppendCStringUtf8# #-}
      -- See the NOINLINE note on unpackCString#
@@ -288,8 +287,12 @@
 
 
 ------------------------------
---- UTF8 decoding utilities
+--- UTF-8 decoding utilities
 ------------------------------
+--
+-- This is one of several UTF-8 implementations provided by GHC; see Note
+-- [GHC's many UTF-8 implementations] in "GHC.Encoding.UTF8" for an
+-- overview.
 --
 -- These functions make explicit the logic that was originally
 -- part of unpackCStringUtf8. Since we want the same support for ascii
diff --git a/GHC/Classes.hs b/GHC/Classes.hs
--- a/GHC/Classes.hs
+++ b/GHC/Classes.hs
@@ -27,6 +27,9 @@
 -- Portability :  non-portable (GHC extensions)
 --
 -- Basic classes.
+-- Do not import this module directly.  It is an GHC internal only
+-- module.  Some of its contents are instead available from @Prelude@
+-- and @GHC.Int@.
 --
 -----------------------------------------------------------------------------
 
@@ -35,6 +38,8 @@
     IP(..),
 
     -- * Equality and ordering
+    -- | Do not import these classes from this module. Import them
+    -- from @Prelude@ instead.
     Eq(..),
     Ord(..),
     -- ** Monomorphic equality operators
@@ -48,6 +53,8 @@
     gtWord, geWord, leWord, ltWord, compareWord, compareWord#,
 
     -- * Functions over Bool
+    -- | Do not import these functions from this module. Import them
+    -- from @Prelude@ instead.
     (&&), (||), not,
 
     -- * Integer arithmetic
@@ -333,10 +340,11 @@
                   else if x <= y then LT
                   else GT
 
-    x <  y = case compare x y of { LT -> True;  _ -> False }
     x <= y = case compare x y of { GT -> False; _ -> True }
-    x >  y = case compare x y of { GT -> True;  _ -> False }
-    x >= y = case compare x y of { LT -> False; _ -> True }
+    x >= y = y <= x
+    x > y = not (x <= y)
+    x < y = not (y <= x)
+
 
         -- These two default methods use '<=' rather than 'compare'
         -- because the latter is often more expensive
diff --git a/GHC/Debug.hs b/GHC/Debug.hs
--- a/GHC/Debug.hs
+++ b/GHC/Debug.hs
@@ -1,6 +1,8 @@
 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes #-}
 
+-- | Users should not import this module.  It is GHC internal only.
+
 module GHC.Debug ( debugLn, debugErrLn ) where
 
 import GHC.Prim
diff --git a/GHC/Magic/Dict.hs b/GHC/Magic/Dict.hs
--- a/GHC/Magic/Dict.hs
+++ b/GHC/Magic/Dict.hs
@@ -29,17 +29,29 @@
 --
 -----------------------------------------------------------------------------
 
-module GHC.Magic.Dict (WithDict(..)) where
+module GHC.Magic.Dict (
+    WithDict( withDict )
+  ) where
 
 import GHC.Types (RuntimeRep, TYPE)
 
--- | @'withDict' d f@ provides a way to call a type-class–overloaded function
--- @f@ by applying it to the supplied dictionary @d@.
+-- | The constraint @'WithDict' cls meth@ can be solved when evidence for
+-- the constraint @cls@ can be provided in the form of a dictionary of
+-- type @meth@. This requires @cls@ to be a class constraint whose single
+-- method has type @meth@.
 --
--- 'withDict' can only be used if the type class has a single method with no
--- superclasses. For more (important) details on how this works, see
+-- For more (important) details on how this works, see
 -- @Note [withDict]@ in "GHC.Tc.Instance.Class" in GHC.
+--
+--   @since 0.9.0
 class WithDict cls meth where
+  -- @'withDict' d f@ provides a way to call a type-class–overloaded function
+  -- @f@ by applying it to the supplied dictionary @d@.
+  --
+  -- 'withDict' can only be used if the type class has a single method with no
+  -- superclasses.
+  --
+  --   @since 0.9.0
   withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). meth -> (cls => r) -> r
 
 {- Note [withDict has an ambiguous type]
diff --git a/GHC/Prim/Exception.hs b/GHC/Prim/Exception.hs
--- a/GHC/Prim/Exception.hs
+++ b/GHC/Prim/Exception.hs
@@ -1,11 +1,10 @@
-{-# LANGUAGE GHCForeignImportPrim #-}
-{-# LANGUAGE UnliftedFFITypes #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE UnboxedTuples #-}
 {-# LANGUAGE NoImplicitPrelude #-}
-{-# LANGUAGE EmptyCase #-}
 
 -- | Primitive exceptions.
+--
+-- Users should not import this module.  It is GHC internal only.
 module GHC.Prim.Exception
    ( raiseOverflow
    , raiseUnderflow
@@ -14,7 +13,7 @@
 where
 
 import GHC.Prim
-import GHC.Magic
+import GHC.Types ()
 
 default () -- Double and Integer aren't available yet
 
@@ -29,25 +28,14 @@
 --
 -- See also: Note [Wired-in exceptions are not CAFfy] in GHC.Core.Make.
 
-foreign import prim "stg_raiseOverflowzh" raiseOverflow# :: State# RealWorld -> (# State# RealWorld, (# #) #)
-foreign import prim "stg_raiseUnderflowzh" raiseUnderflow# :: State# RealWorld -> (# State# RealWorld, (# #) #)
-foreign import prim "stg_raiseDivZZerozh" raiseDivZero# :: State# RealWorld -> (# State# RealWorld, (# #) #)
-
--- We give a bottoming demand signature to 'raiseOverflow', 'raiseUnderflow' and
--- 'raiseDivZero' in "GHC.Core.Make". NOINLINE pragmas are necessary because if
--- we ever inlined them we would lose that information.
-
 -- | Raise 'GHC.Exception.Type.overflowException'
 raiseOverflow :: a
-{-# NOINLINE raiseOverflow #-}
-raiseOverflow = runRW# (\s -> case raiseOverflow# s of (# _, _ #) -> let x = x in x)
+raiseOverflow = raiseOverflow# (# #)
 
 -- | Raise 'GHC.Exception.Type.underflowException'
 raiseUnderflow :: a
-{-# NOINLINE raiseUnderflow #-}
-raiseUnderflow = runRW# (\s -> case raiseUnderflow# s of (# _, _ #) -> let x = x in x)
+raiseUnderflow = raiseUnderflow# (# #)
 
 -- | Raise 'GHC.Exception.Type.divZeroException'
 raiseDivZero :: a
-{-# NOINLINE raiseDivZero #-}
-raiseDivZero = runRW# (\s -> case raiseDivZero# s of (# _, _ #) -> let x = x in x)
+raiseDivZero = raiseDivZero# (# #)
diff --git a/GHC/Prim/Ext.hs b/GHC/Prim/Ext.hs
--- a/GHC/Prim/Ext.hs
+++ b/GHC/Prim/Ext.hs
@@ -18,6 +18,9 @@
 
 -- | Extra C-- routines exposed from the RTS
 --
+-- Users should not import this module.  It is GHC internal only.  Use
+-- "GHC.Conc" instead.
+--
 -- Actual primops are emitted by the compiler itself. They are special bits of
 -- code with backend support. The foreign functions in this module aren't actual
 -- primops because the compiler doesn't care about them at all: they just are
diff --git a/GHC/Prim/Panic.hs b/GHC/Prim/Panic.hs
--- a/GHC/Prim/Panic.hs
+++ b/GHC/Prim/Panic.hs
@@ -4,17 +4,21 @@
 {-# LANGUAGE UnboxedTuples #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE EmptyCase #-}
+{-# LANGUAGE RankNTypes, KindSignatures #-}
 
 -- | Primitive panics.
+--
+-- Users should not import this module.  It is GHC internal only.
 module GHC.Prim.Panic
    ( absentSumFieldError
    , panicError
-   , absentError
+   , absentError, absentConstraintError
    )
 where
 
 import GHC.Prim
 import GHC.Magic
+import GHC.Types( Type )
 
 default () -- Double and Integer aren't available yet
 
@@ -93,7 +97,7 @@
 
 -- | Displays "Oops!  Entered absent arg" ++ errormsg and exits the program.
 {-# NOINLINE absentError #-}
-absentError :: Addr# -> a
+absentError :: forall (a :: Type). Addr# -> a
 absentError errmsg =
   runRW# (\s ->
     case stg_absentError# errmsg s of
@@ -101,3 +105,15 @@
                     -- use an empty case lest the pattern match
                     -- checker squawks.
                     let x = x in x)
+
+{-# NOINLINE absentConstraintError #-}
+absentConstraintError :: forall (a :: Type). Addr# -> a
+-- We want to give this the type
+--    forall (a :: Constraint). Addr# -> a
+-- but Haskell source code doesn't allow functions that return Constraint
+-- So in this module we lie about the type.  This is fine because
+-- absentConstraintError is a wired-in Id with the desired Constraint-kinded
+-- type; the type in the interface file is never looked at.
+-- The only purpose of this definition is to give a function to call,
+-- and for that purpose, delegating to absentError is fine.
+absentConstraintError errmsg = absentError errmsg
diff --git a/GHC/Prim/PtrEq.hs b/GHC/Prim/PtrEq.hs
--- a/GHC/Prim/PtrEq.hs
+++ b/GHC/Prim/PtrEq.hs
@@ -1,6 +1,8 @@
 {-# LANGUAGE Unsafe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE MagicHash #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE KindSignatures #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -20,6 +22,7 @@
 
 module GHC.Prim.PtrEq
   ( reallyUnsafePtrEquality,
+    unsafePtrEquality#,
     sameArray#,
     sameMutableArray#,
     sameSmallArray#,
@@ -30,11 +33,12 @@
     sameTVar#,
     sameMVar#,
     sameIOPort#,
+    samePromptTag#,
     eqStableName#
   ) where
 
 import GHC.Prim
-import GHC.Types () -- Make implicit dependency known to build system
+import GHC.Types (UnliftedType) -- Also make implicit dependency known to build system
 default () -- Double and Integer aren't available yet
 
 {- **********************************************************************
@@ -73,46 +77,63 @@
 -- See Note [Pointer comparison operations]
 --   in primops.txt.pp
 
+-- | Compare the underlying pointers of two unlifted values for equality.
+--
+-- This is less dangerous than 'reallyUnsafePtrEquality',
+-- since the arguments are guaranteed to be evaluated.
+-- This means there is no risk of accidentally comparing
+-- a thunk.
+-- It's however still more dangerous than e.g. 'sameArray#'.
+--
+unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int#
+unsafePtrEquality# = reallyUnsafePtrEquality#
+-- See Note [Pointer comparison operations]
+--   in primops.txt.pp
+
 -- | Compare the underlying pointers of two arrays.
 sameArray# :: Array# a -> Array# a -> Int#
-sameArray# = reallyUnsafePtrEquality#
+sameArray# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two mutable arrays.
 sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#
-sameMutableArray# = reallyUnsafePtrEquality#
+sameMutableArray# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two small arrays.
 sameSmallArray# :: SmallArray# a -> SmallArray# a -> Int#
-sameSmallArray# = reallyUnsafePtrEquality#
+sameSmallArray# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two small mutable arrays.
 sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
-sameSmallMutableArray# = reallyUnsafePtrEquality#
+sameSmallMutableArray# = unsafePtrEquality#
 
 -- | Compare the pointers of two byte arrays.
 sameByteArray# :: ByteArray# -> ByteArray# -> Int#
-sameByteArray# = reallyUnsafePtrEquality#
+sameByteArray# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two mutable byte arrays.
 sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#
-sameMutableByteArray# = reallyUnsafePtrEquality#
+sameMutableByteArray# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two 'MutVar#'s.
 sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#
-sameMutVar# = reallyUnsafePtrEquality#
+sameMutVar# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two 'TVar#'s.
 sameTVar# :: TVar# s a -> TVar# s a -> Int#
-sameTVar# = reallyUnsafePtrEquality#
+sameTVar# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two 'MVar#'s.
 sameMVar# :: MVar# s a -> MVar# s a -> Int#
-sameMVar# = reallyUnsafePtrEquality#
+sameMVar# = unsafePtrEquality#
 
 -- | Compare the underlying pointers of two 'IOPort#'s.
 sameIOPort# :: IOPort# s a -> IOPort# s a -> Int#
-sameIOPort# = reallyUnsafePtrEquality#
+sameIOPort# = unsafePtrEquality#
 
+-- | Compare the underlying pointers of two 'PromptTag#'s.
+samePromptTag# :: PromptTag# a -> PromptTag# a -> Int#
+samePromptTag# = unsafePtrEquality#
+
 -- Note [Comparing stable names]
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- A StableName# is actually a pointer to a stable name object (SNO)
@@ -125,4 +146,4 @@
 
 -- | Compare two stable names for equality.
 eqStableName# :: StableName# a -> StableName# b -> Int#
-eqStableName# = reallyUnsafePtrEquality#
+eqStableName# = unsafePtrEquality#
diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs
--- a/GHC/PrimopWrappers.hs
+++ b/GHC/PrimopWrappers.hs
@@ -1,9 +1,11 @@
+-- | Users should not import this module.  It is GHC internal only.
+-- Use "GHC.Exts" instead.
 {-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples #-}
-{-# OPTIONS_GHC -Wno-deprecations -O0 #-}
+{-# OPTIONS_GHC -Wno-deprecations -O0 -fno-do-eta-reduction #-}
 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, 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#, MutVar#, RealWorld, PromptTag#, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO)
 {-# NOINLINE gtChar# #-}
 gtChar# :: Char# -> Char# -> Int#
 gtChar# a1 a2 = GHC.Prim.gtChar# a1 a2
@@ -1696,6 +1698,15 @@
 {-# NOINLINE raise# #-}
 raise# :: v -> p
 raise# a1 = GHC.Prim.raise# a1
+{-# NOINLINE raiseUnderflow# #-}
+raiseUnderflow# :: (#  #) -> p
+raiseUnderflow# a1 = GHC.Prim.raiseUnderflow# a1
+{-# NOINLINE raiseOverflow# #-}
+raiseOverflow# :: (#  #) -> p
+raiseOverflow# a1 = GHC.Prim.raiseOverflow# a1
+{-# NOINLINE raiseDivZero# #-}
+raiseDivZero# :: (#  #) -> p
+raiseDivZero# a1 = GHC.Prim.raiseDivZero# a1
 {-# NOINLINE raiseIO# #-}
 raiseIO# :: v -> State# (RealWorld) -> (# State# (RealWorld),p #)
 raiseIO# a1 a2 = GHC.Prim.raiseIO# a1 a2
@@ -1711,6 +1722,15 @@
 {-# NOINLINE getMaskingState# #-}
 getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
 getMaskingState# a1 = GHC.Prim.getMaskingState# a1
+{-# NOINLINE newPromptTag# #-}
+newPromptTag# :: State# (RealWorld) -> (# State# (RealWorld),PromptTag# a #)
+newPromptTag# a1 = GHC.Prim.newPromptTag# a1
+{-# NOINLINE prompt# #-}
+prompt# :: PromptTag# a -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
+prompt# a1 a2 a3 = GHC.Prim.prompt# a1 a2 a3
+{-# NOINLINE control0# #-}
+control0# :: PromptTag# a -> (((State# (RealWorld) -> (# State# (RealWorld),p #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),p #)
+control0# a1 a2 a3 = GHC.Prim.control0# a1 a2 a3
 {-# NOINLINE atomically# #-}
 atomically# :: (State# (RealWorld) -> (# State# (RealWorld),v #)) -> State# (RealWorld) -> (# State# (RealWorld),v #)
 atomically# a1 a2 = GHC.Prim.atomically# a1 a2
@@ -1793,7 +1813,7 @@
 myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
 myThreadId# a1 = GHC.Prim.myThreadId# a1
 {-# NOINLINE labelThread# #-}
-labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)
+labelThread# :: ThreadId# -> ByteArray# -> State# (RealWorld) -> State# (RealWorld)
 labelThread# a1 a2 a3 = GHC.Prim.labelThread# a1 a2 a3
 {-# NOINLINE isCurrentThreadBound# #-}
 isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
@@ -1801,9 +1821,15 @@
 {-# NOINLINE noDuplicate# #-}
 noDuplicate# :: State# s -> State# s
 noDuplicate# a1 = GHC.Prim.noDuplicate# a1
+{-# NOINLINE threadLabel# #-}
+threadLabel# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,ByteArray# #)
+threadLabel# a1 a2 = GHC.Prim.threadLabel# a1 a2
 {-# NOINLINE threadStatus# #-}
 threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)
 threadStatus# a1 a2 = GHC.Prim.threadStatus# a1 a2
+{-# NOINLINE listThreads# #-}
+listThreads# :: State# (RealWorld) -> (# State# (RealWorld),Array# (ThreadId#) #)
+listThreads# a1 = GHC.Prim.listThreads# a1
 {-# NOINLINE mkWeak# #-}
 mkWeak# :: v -> w -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# w #)
 mkWeak# a1 a2 a3 a4 = GHC.Prim.mkWeak# a1 a2 a3 a4
@@ -1895,7 +1921,7 @@
 dataToTag# :: a -> Int#
 dataToTag# a1 = GHC.Prim.dataToTag# a1
 {-# NOINLINE addrToAny# #-}
-addrToAny# :: Addr# -> (# a #)
+addrToAny# :: Addr# -> (# v #)
 addrToAny# a1 = GHC.Prim.addrToAny# a1
 {-# NOINLINE anyToAddr# #-}
 anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #)
diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs
--- a/GHC/Tuple.hs
+++ b/GHC/Tuple.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE NoImplicitPrelude, DeriveGeneric #-}
+{-# LANGUAGE NoImplicitPrelude, PatternSynonyms #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  GHC.Tuple
@@ -12,221 +12,23 @@
 --
 -- The tuple data types
 --
+-- Users should not import this module.  It is GHC internal only.
+--
 -----------------------------------------------------------------------------
 
-module GHC.Tuple where
+module GHC.Tuple (
+  module GHC.Tuple.Prim,
+  Solo (Solo, MkSolo),
+) where
 
 import GHC.CString ()  -- Make sure we do it first, so that the
                        -- implicit Typeable stuff can see GHC.Types.TyCon
                        -- and unpackCString# etc
+import GHC.Tuple.Prim
 
 default () -- Double and Integer aren't available yet
 
--- | The unit datatype @()@ has one non-undefined member, the nullary
--- constructor @()@.
-data () = ()
-
--- The desugarer uses 1-tuples,
--- but "()" 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).
---
--- The most important feature of @Solo@ is that it is possible to force its
--- "outside" (usually by pattern matching) without forcing its "inside",
--- because it is defined as a datatype rather than a newtype. One situation
--- where this can be useful is when writing a function to extract a value from
--- a data structure. Suppose you write an implementation of arrays and offer
--- only this function to index into them:
---
--- @
--- index :: Array a -> Int -> a
--- @
---
--- Now imagine that someone wants to extract a value from an array and store it
--- in a lazy-valued finite map/dictionary:
---
--- @
--- insert "hello" (arr `index` 12) m
--- @
---
--- This can actually lead to a space leak. The value is not actually extracted
--- from the array until that value (now buried in a map) is forced. That means
--- the entire array may be kept live by just that value!  Often, the solution
--- is to use a strict map, or to force the value before storing it, but for
--- some purposes that's undesirable.
---
--- One common solution is to include an indexing function that can produce its
--- result in an arbitrary @Applicative@ context:
---
--- @
--- indexA :: Applicative f => Array a -> Int -> f a
--- @
---
--- When using @indexA@ in a /pure/ context, @Solo@ serves as a handy
--- @Applicative@ functor to hold the result. You could write a non-leaky
--- version of the above example thus:
---
--- @
--- case arr `indexA` 12 of
---   Solo a -> insert "hello" a m
--- @
---
--- While such simple extraction functions are the most common uses for
--- unary tuples, they can also be useful for fine-grained control of
--- strict-spined data structure traversals, and for unifying the
--- implementations of lazy and strict mapping functions.
-data Solo a = Solo a
-
-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
--- record fields is a bit more inconvenient than if it doesn't.
--- (No other wired-in TyCon has record fields.)  So it seems easier
--- to have getSolo as its own separate function (#20562)
-getSolo (Solo 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)
-
-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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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)
+{-# DEPRECATED Solo "The Solo constructor has been renamed to MkSolo to avoid punning." #-}
+pattern Solo :: a -> Solo a
+pattern Solo x = MkSolo x
+{-# COMPLETE Solo #-}
diff --git a/GHC/Tuple/Prim.hs b/GHC/Tuple/Prim.hs
new file mode 100644
--- /dev/null
+++ b/GHC/Tuple/Prim.hs
@@ -0,0 +1,232 @@
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE NoImplicitPrelude, DeriveGeneric #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  GHC.Tuple.Prim
+-- 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)
+--
+-- The tuple data types
+--
+-----------------------------------------------------------------------------
+
+module GHC.Tuple.Prim where
+
+import GHC.CString ()  -- Make sure we do it first, so that the
+                       -- implicit Typeable stuff can see GHC.Types.TyCon
+                       -- and unpackCString# etc
+
+default () -- Double and Integer aren't available yet
+
+-- | The unit datatype @()@ has one non-undefined member, the nullary
+-- constructor @()@.
+data () = ()
+
+-- The desugarer uses 1-tuples,
+-- but "()" 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).
+--
+-- The most important feature of @Solo@ is that it is possible to force its
+-- "outside" (usually by pattern matching) without forcing its "inside",
+-- because it is defined as a datatype rather than a newtype. One situation
+-- where this can be useful is when writing a function to extract a value from
+-- a data structure. Suppose you write an implementation of arrays and offer
+-- only this function to index into them:
+--
+-- @
+-- index :: Array a -> Int -> a
+-- @
+--
+-- Now imagine that someone wants to extract a value from an array and store it
+-- in a lazy-valued finite map/dictionary:
+--
+-- @
+-- insert "hello" (arr `index` 12) m
+-- @
+--
+-- This can actually lead to a space leak. The value is not actually extracted
+-- from the array until that value (now buried in a map) is forced. That means
+-- the entire array may be kept live by just that value!  Often, the solution
+-- is to use a strict map, or to force the value before storing it, but for
+-- some purposes that's undesirable.
+--
+-- One common solution is to include an indexing function that can produce its
+-- result in an arbitrary @Applicative@ context:
+--
+-- @
+-- indexA :: Applicative f => Array a -> Int -> f a
+-- @
+--
+-- When using @indexA@ in a /pure/ context, @Solo@ serves as a handy
+-- @Applicative@ functor to hold the result. You could write a non-leaky
+-- version of the above example thus:
+--
+-- @
+-- case arr `indexA` 12 of
+--   Solo a -> insert "hello" a m
+-- @
+--
+-- While such simple extraction functions are the most common uses for
+-- unary tuples, they can also be useful for fine-grained control of
+-- strict-spined data structure traversals, and for unifying the
+-- implementations of lazy and strict mapping functions.
+data Solo a = MkSolo a
+
+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
+-- record fields is a bit more inconvenient than if it doesn't.
+-- (No other wired-in TyCon has record fields.)  So it seems easier
+-- 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)
+
+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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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,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
@@ -1,7 +1,7 @@
 {-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples,
              MultiParamTypeClasses, RoleAnnotations, CPP, TypeOperators,
              PolyKinds, NegativeLiterals, DataKinds, ScopedTypeVariables,
-             TypeApplications, StandaloneKindSignatures,
+             TypeApplications, StandaloneKindSignatures, GADTs,
              FlexibleInstances, UndecidableInstances #-}
 -- NegativeLiterals: see Note [Fixity of (->)]
 {-# OPTIONS_HADDOCK print-explicit-runtime-reps #-}
@@ -22,16 +22,15 @@
 -----------------------------------------------------------------------------
 
 module GHC.Types (
-        -- Data types that are built-in syntax
-        -- They are defined here, but not explicitly exported
-        --
-        --    Lists:          []( [], (:) )
-        --    Type equality:  (~)( Eq# )
-
         -- * Built-in types
         Bool(..), Char(..), Int(..), Word(..),
         Float(..), Double(..),
         Ordering(..), IO(..),
+
+        List,   -- List( [], (:) )
+          -- List constructors are not exported
+          -- because they are built-in syntax
+
         isTrue#,
         SPEC(..),
         Symbol,
@@ -41,7 +40,8 @@
         type (~), type (~~), Coercible,
 
         -- * Representation polymorphism
-        TYPE, Levity(..), RuntimeRep(..),
+        TYPE, CONSTRAINT,
+        Levity(..), RuntimeRep(..),
         LiftedRep, UnliftedRep,
         Type, UnliftedType, Constraint,
           -- The historical type * should ideally be written as
@@ -51,6 +51,11 @@
         VecCount(..), VecElem(..),
         Void#,
 
+        -- * Boxing constructors
+        DictBox( MkDictBox ),
+        WordBox( MkWordBox), IntBox( MkIntBox),
+        FloatBox( MkFloatBox), DoubleBox( MkDoubleBox),
+
         -- * Multiplicity types
         Multiplicity(..), MultMul,
 
@@ -63,7 +68,6 @@
 
 infixr 5 :
 
-
 {- *********************************************************************
 *                                                                      *
                   Functions
@@ -93,9 +97,8 @@
 *                                                                      *
 ********************************************************************* -}
 
--- | The kind of constraints, like @Show a@
-data Constraint
 
+
 -- | The runtime representation of lifted types.
 type LiftedRep = 'BoxedRep 'Lifted
 
@@ -107,6 +110,9 @@
 type ZeroBitRep = 'TupleRep '[]
 
 -------------------------
+-- | The kind of lifted constraints
+type Constraint = CONSTRAINT LiftedRep
+
 -- | The kind of types with lifted values. For example @Int :: Type@.
 type Type = TYPE LiftedRep
 
@@ -133,9 +139,10 @@
 ********************************************************************* -}
 
 -- | (Kind) This is the kind of type-level symbols.
--- Declared here because class IP needs it
 data Symbol
 
+-- Symbol is declared here because class IP needs it
+
 {- *********************************************************************
 *                                                                      *
                   Any
@@ -144,7 +151,7 @@
 
 -- | The type constructor 'Any' is type to which you can unsafely coerce any
 -- lifted type, and back. More concretely, for a lifted type @t@ and
--- value @x :: t@, -- @unsafeCoerce (unsafeCoerce x :: Any) :: t@ is equivalent
+-- value @x :: t@, @unsafeCoerce (unsafeCoerce x :: Any) :: t@ is equivalent
 -- to @x@.
 --
 type family Any :: k where { }
@@ -166,7 +173,7 @@
 -- ==== __Examples__
 --
 -- Unless the OverloadedLists extension is enabled, list literals are
--- syntatic sugar for repeated applications of @:@ and @[]@.
+-- syntactic sugar for repeated applications of @:@ and @[]@.
 --
 -- >>> 1:2:3:4:[] == [1,2,3,4]
 -- True
@@ -177,7 +184,7 @@
 -- >>> ['h','e','l','l','o'] == "hello"
 -- True
 --
-data [] a = [] | a : [a]
+data List a = [] | a : List a
 
 
 {- *********************************************************************
@@ -343,7 +350,7 @@
 --      <http://research.microsoft.com/en-us/um/people/simonpj/papers/ext-f/coercible.pdf Safe Coercions>
 --      by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.
 --
---      @since 4.7.0.0
+-- @since 0.4.0
 class Coercible (a :: k) (b :: k)
   -- See also Note [The equality types story] in GHC.Builtin.Types.Prim
 
@@ -473,7 +480,7 @@
 -- RuntimeRep is intimately tied to TyCon.RuntimeRep (in GHC proper). See
 -- Note [RuntimeRep and PrimRep] in RepType.
 -- See also Note [Wiring in RuntimeRep] in GHC.Builtin.Types
--- See also Note [TYPE and RuntimeRep] in GHC.Builtin.Type.Prim
+-- See also Note [TYPE and CONSTRAINT] in GHC.Builtin.Type.Prim
 
 -- | Length of a SIMD vector type
 data VecCount = Vec2
@@ -499,6 +506,37 @@
 
 {-# DEPRECATED Void# "Void# is now an alias for the unboxed tuple (# #)." #-}
 type Void# = (# #)
+
+{- *********************************************************************
+*                                                                      *
+             Boxing data constructors
+*                                                                      *
+********************************************************************* -}
+
+-- These "boxing" data types allow us to wrap up a value of kind (TYPE rr)
+-- in a box of kind Type, for each rr.
+data LiftBox   (a :: TYPE UnliftedRep) = MkLiftBox a
+
+data IntBox    (a :: TYPE IntRep)      = MkIntBox a
+data Int8Box   (a :: TYPE Int8Rep)     = MkInt8Box a
+data Int16Box  (a :: TYPE Int16Rep)    = MkInt16Box a
+data Int32Box  (a :: TYPE Int32Rep)    = MkInt32Box a
+data Int64Box  (a :: TYPE Int64Rep)    = MkInt64Box a
+
+data WordBox   (a :: TYPE WordRep)     = MkWordBox a
+data Word8Box  (a :: TYPE Word8Rep)    = MkWord8Box a
+data Word16Box (a :: TYPE Word16Rep)   = MkWord16Box a
+data Word32Box (a :: TYPE Word32Rep)   = MkWord32Box a
+data Word64Box (a :: TYPE Word64Rep)   = MkWord64Box a
+
+data FloatBox  (a :: TYPE FloatRep)    = MkFloatBox a
+data DoubleBox (a :: TYPE DoubleRep)   = MkDoubleBox a
+
+-- | Data type `Dict` provides a simple way to wrap up a (lifted)
+--   constraint as a type
+data DictBox c where
+  MkDictBox :: c => DictBox c
+
 
 {- *********************************************************************
 *                                                                      *
diff --git a/cbits/atomic.c b/cbits/atomic.c
--- a/cbits/atomic.c
+++ b/cbits/atomic.c
@@ -308,8 +308,8 @@
   return __sync_val_compare_and_swap((volatile StgWord32 *) x, (StgWord32) old, (StgWord32) new);
 }
 
-extern StgWord hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new);
-StgWord
+extern StgWord64 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new);
+StgWord64
 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new)
 {
   return __sync_val_compare_and_swap((volatile StgWord64 *) x, old, new);
diff --git a/cbits/mulIntMayOflo.c b/cbits/mulIntMayOflo.c
new file mode 100644
--- /dev/null
+++ b/cbits/mulIntMayOflo.c
@@ -0,0 +1,3 @@
+#include "Rts.h"
+
+W_ hs_mulIntMayOflo(W_ a, W_ b) { return mulIntMayOflo(a, b); }
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,33 @@
+## 0.10.0
+
+- Shipped with GHC 9.6.1
+
+- The `listThreads#` primop was added, allowing the user to enumerate all
+  threads (running and blocked) in the program:
+  ```haskell
+  listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #)
+  ```
+
+- The type of the `labelThread#` primop was changed from:
+  ```haskell
+  labelThread# :: ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
+  ```
+  to
+  ```haskell
+  labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld
+  ```
+  Where the `ByteArray#` must contain a UTF-8-encoded string.
+
+- The `threadLabel#` primop was added, allowing the user to query the label of
+  a given `ThreadId#`.
+
+- `isByteArrayPinned#` now only considers an array pinned if it was explicitly pinned
+  by the user. This is required to avoid ghc issue [#22255](https://gitlab.haskell.org/ghc/ghc/-/issues/22255)
+  which showed that the old behaviour could cause segfaults when used in combination
+  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.
+
 ## 0.9.0 *August 2022*
 
 - Shipped with GHC 9.4.1
@@ -5,9 +35,8 @@
 - `magicDict` has been renamed to `withDict` and is now defined in
   `GHC.Magic.Dict` instead of `GHC.Prim`. `withDict` now has the type:
 
-  ```
-  class WithDict cls meth where
-    withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). meth -> (cls => r) -> r
+  ```haskell
+  withDict :: forall {rr :: RuntimeRep} st dt (r :: TYPE rr). st -> (dt => r) -> r
   ```
 
   Unlike `magicDict`, `withDict` can be used without defining an
@@ -17,10 +46,10 @@
   ```haskell
   withTypeable :: forall k (a :: k) rep (r :: TYPE rep). ()
                => TypeRep a -> (Typeable a => r) -> r
-  withTypeable rep k = withDict @(Typeable a) rep k
+  withTypeable rep k = withDict @(TypeRep a) @(Typeable a) rep k
   ```
 
-  Note that the explicit type application is required, as the call to
+  Note that the explicit type applications are required, as the call to
   `withDict` would be ambiguous otherwise.
 
 - Primitive types and functions which handle boxed values are now levity-polymorphic,
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.9.0
+version:        0.10.0
 -- NOTE: Don't forget to update ./changelog.md
 license:        BSD-3-Clause
 license-file:   LICENSE
@@ -12,6 +12,11 @@
 description:
     This package contains the primitive types and operations supplied by GHC.
 
+    It is an internal package, only for the use of GHC developers.
+    GHC users should not use it!  If you do use it then expect
+    breaking changes at any time without warning.  You should prefer
+    to import @GHC.Exts@ from the @base@ package instead.
+
 extra-source-files: changelog.md
 
 source-repository head
@@ -51,6 +56,7 @@
         GHC.Prim.PtrEq
         GHC.PrimopWrappers
         GHC.Tuple
+        GHC.Tuple.Prim
         GHC.Types
 
     virtual-modules:
@@ -60,33 +66,34 @@
     if os(windows)
         -- Windows requires some extra libraries for linking because the RTS
         -- is no longer re-exporting them (see #11223)
-        -- msvcrt: standard C library. The RTS will automatically include this,
-        --         but is added for completeness.
-        -- mingwex: provides C99 compatibility. libm is a stub on MingW.
+        -- ucrt: standard C library. The RTS will automatically include this,
+        --       but is added for completeness.
         -- 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, mingwex, ucrt
+        extra-libraries: user32, mingw32, 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
 
-    c-sources:
-        cbits/atomic.c
-        cbits/bswap.c
-        cbits/bitrev.c
-        cbits/clz.c
-        cbits/ctz.c
-        cbits/debug.c
-        cbits/longlong.c
-        cbits/pdep.c
-        cbits/pext.c
-        cbits/popcnt.c
-        cbits/word2float.c
+    if !os(ghcjs)
+      c-sources:
+          cbits/atomic.c
+          cbits/bswap.c
+          cbits/bitrev.c
+          cbits/clz.c
+          cbits/ctz.c
+          cbits/debug.c
+          cbits/longlong.c
+          cbits/mulIntMayOflo.c
+          cbits/pdep.c
+          cbits/pext.c
+          cbits/popcnt.c
+          cbits/word2float.c
 
     -- We need to set the unit ID to ghc-prim (without a version number)
     -- as it's magic.