ghc-prim 0.9.0 → 0.10.0

raw patch · 16 files changed

+487/−297 lines, 16 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• GHC/CString.hs +5/−2
• GHC/Classes.hs +11/−3
• GHC/Debug.hs +2/−0
• GHC/Magic/Dict.hs +17/−5
• GHC/Prim/Exception.hs +6/−18
• GHC/Prim/Ext.hs +3/−0
• GHC/Prim/Panic.hs +18/−2
• GHC/Prim/PtrEq.hs +33/−12
• GHC/PrimopWrappers.hs +30/−4
• GHC/Tuple.hs +12/−210
• GHC/Tuple/Prim.hs +232/−0
• GHC/Types.hs +55/−17
• cbits/atomic.c +2/−2
• cbits/mulIntMayOflo.c +3/−0
• changelog.md +34/−5
• ghc-prim.cabal +24/−17

@@ -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

@@ -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

@@ -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

@@ -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]

@@ -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# (# #)

@@ -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

@@ -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

@@ -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#

@@ -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# #)

@@ -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 #-}

@@ -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)

@@ -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+  {- ********************************************************************* *                                                                      *

@@ -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);

@@ -0,0 +1,3 @@+#include "Rts.h"++W_ hs_mulIntMayOflo(W_ a, W_ b) { return mulIntMayOflo(a, b); }

@@ -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,

@@ -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.