compiler/prelude/PrelNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[PrelNames]{Definitions of prelude modules and names}
   5
   6
   7 Nota Bene: all Names defined in here should come from the base package
   8
   9  - ModuleNames for prelude modules,
  10         e.g.    pREL_BASE_Name :: ModuleName
  11
  12  - Modules for prelude modules
  13         e.g.    pREL_Base :: Module
  14
  15  - Uniques for Ids, DataCons, TyCons and Classes that the compiler
  16    "knows about" in some way
  17         e.g.    intTyConKey :: Unique
  18                 minusClassOpKey :: Unique
  19
  20  - Names for Ids, DataCons, TyCons and Classes that the compiler
  21    "knows about" in some way
  22         e.g.    intTyConName :: Name
  23                 minusName    :: Name
  24    One of these Names contains
  25         (a) the module and occurrence name of the thing
  26         (b) its Unique
  27    The may way the compiler "knows about" one of these things is
  28    where the type checker or desugarer needs to look it up. For
  29    example, when desugaring list comprehensions the desugarer
  30    needs to conjure up 'foldr'.  It does this by looking up
  31    foldrName in the environment.
  32
  33  - RdrNames for Ids, DataCons etc that the compiler may emit into
  34    generated code (e.g. for deriving).  It's not necessary to know
  35    the uniques for these guys, only their names
  36
  37
  38 \begin{code}
  39 module PrelNames (
  40         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
  41
  42         -----------------------------------------------------------
  43         module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName
  44                                 --                 (b) Uniques e.g. intTyConKey
  45                                 --                 (c) Groups of classes and types
  46                                 --                 (d) miscellaneous things
  47                                 -- So many that we export them all
  48     ) where
  49
  50 #include "HsVersions.h"
  51
  52 import Module
  53 import OccName
  54 import RdrName    ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
  55 import Unique     ( Unique, Uniquable(..), hasKey,
  56                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
  57                     mkPreludeTyConUnique, mkPreludeClassUnique,
  58                     mkTupleTyConUnique
  59                   )
  60 import BasicTypes ( Boxity(..), Arity )
  61 import Name       ( Name, mkInternalName, mkExternalName )
  62 import SrcLoc
  63 import FastString
  64 \end{code}
  65
  66
  67 %************************************************************************
  68 %*                                                                      *
  69 \subsection{Local Names}
  70 %*                                                                      *
  71 %************************************************************************
  72
  73 This *local* name is used by the interactive stuff
  74
  75 \begin{code}
  76 itName :: Unique -> Name
  77 itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan
  78 \end{code}
  79
  80 \begin{code}
  81 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
  82 -- during compiler debugging.
  83 mkUnboundName :: RdrName -> Name
  84 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan
  85
  86 isUnboundName :: Name -> Bool
  87 isUnboundName name = name `hasKey` unboundKey
  88 \end{code}
  89
  90
  91 %************************************************************************
  92 %*                                                                      *
  93 \subsection{Known key Names}
  94 %*                                                                      *
  95 %************************************************************************
  96
  97 This section tells what the compiler knows about the assocation of
  98 names with uniques.  These ones are the *non* wired-in ones.  The
  99 wired in ones are defined in TysWiredIn etc.
 100
 101 \begin{code}
 102 basicKnownKeyNames :: [Name]
 103 basicKnownKeyNames
 104  = genericTyConNames
 105  ++ typeableClassNames
 106  ++ [   -- Type constructors (synonyms especially)
 107         ioTyConName, ioDataConName,
 108         runMainIOName,
 109         orderingTyConName,
 110         rationalTyConName,
 111         stringTyConName,
 112         ratioDataConName,
 113         ratioTyConName,
 114         integerTyConName, smallIntegerName,
 115
 116         --  Classes.  *Must* include:
 117         --      classes that are grabbed by key (e.g., eqClassKey)
 118         --      classes in "Class.standardClassKeys" (quite a few)
 119         eqClassName,                    -- mentioned, derivable
 120         ordClassName,                   -- derivable
 121         boundedClassName,               -- derivable
 122         numClassName,                   -- mentioned, numeric
 123         enumClassName,                  -- derivable
 124         monadClassName,
 125         functorClassName,
 126         realClassName,                  -- numeric
 127         integralClassName,              -- numeric
 128         fractionalClassName,            -- numeric
 129         floatingClassName,              -- numeric
 130         realFracClassName,              -- numeric
 131         realFloatClassName,             -- numeric
 132         dataClassName,
 133         isStringClassName,
 134
 135         -- Numeric stuff
 136         negateName, minusName,
 137         fromRationalName, fromIntegerName,
 138         geName, eqName,
 139
 140         -- String stuff
 141         fromStringName,
 142
 143         -- Enum stuff
 144         enumFromName, enumFromThenName,
 145         enumFromThenToName, enumFromToName,
 146         enumFromToPName, enumFromThenToPName,
 147
 148         -- Monad stuff
 149         thenIOName, bindIOName, returnIOName, failIOName,
 150         failMName, bindMName, thenMName, returnMName,
 151
 152         -- MonadRec stuff
 153         mfixName,
 154
 155         -- Arrow stuff
 156         arrAName, composeAName, firstAName,
 157         appAName, choiceAName, loopAName,
 158
 159         -- Ix stuff
 160         ixClassName,
 161
 162         -- Show stuff
 163         showClassName,
 164
 165         -- Read stuff
 166         readClassName,
 167
 168         -- Stable pointers
 169         newStablePtrName,
 170
 171     -- GHC Extensions
 172     groupWithName,
 173
 174         -- Strings and lists
 175         unpackCStringName, unpackCStringAppendName,
 176         unpackCStringFoldrName, unpackCStringUtf8Name,
 177
 178         -- List operations
 179         concatName, filterName, mapName,
 180         zipName, foldrName, buildName, augmentName, appendName,
 181
 182         -- Parallel array operations
 183         nullPName, lengthPName, replicatePName, singletonPName, mapPName,
 184         filterPName, zipPName, crossMapPName, indexPName,
 185         toPName, bpermutePName, bpermuteDftPName, indexOfPName,
 186
 187         -- FFI primitive types that are not wired-in.
 188         stablePtrTyConName, ptrTyConName, funPtrTyConName,
 189         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
 190         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 191
 192         -- Others
 193         otherwiseIdName, inlineIdName,
 194         plusIntegerName, timesIntegerName,
 195         eqStringName, assertName, breakpointName, breakpointCondName,
 196         breakpointAutoName,  opaqueTyConName,
 197         assertErrorName, runSTRepName,
 198         printName, fstName, sndName,
 199
 200         -- MonadFix
 201         monadFixClassName, mfixName,
 202
 203         -- Other classes
 204         randomClassName, randomGenClassName, monadPlusClassName,
 205
 206         -- Booleans
 207         andName, orName
 208
 209         -- The Either type
 210         , eitherTyConName, leftDataConName, rightDataConName
 211
 212         -- dotnet interop
 213         , objectTyConName, marshalObjectName, unmarshalObjectName
 214         , marshalStringName, unmarshalStringName, checkDotnetResName
 215     ]
 216
 217 genericTyConNames :: [Name]
 218 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
 219 \end{code}
 220
 221
 222 %************************************************************************
 223 %*                                                                      *
 224 \subsection{Module names}
 225 %*                                                                      *
 226 %************************************************************************
 227
 228
 229 --MetaHaskell Extension Add a new module here
 230 \begin{code}
 231 pRELUDE :: Module
 232 pRELUDE         = mkBaseModule_ pRELUDE_NAME
 233
 234 gHC_PRIM, gHC_TYPES, gHC_BOOL, gHC_UNIT, gHC_ORDERING, gHC_GENERICS, gHC_BASE, gHC_ENUM,
 235     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_LIST, gHC_PARR,
 236     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, gHC_PACK, gHC_CONC, gHC_IO_BASE,
 237     gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
 238     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
 239     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW,
 240     gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION :: Module
 241 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
 242 gHC_TYPES   = mkPrimModule (fsLit "GHC.Types")
 243 gHC_UNIT        = mkPrimModule (fsLit "GHC.Unit")
 244 gHC_BOOL        = mkPrimModule (fsLit "GHC.Bool")
 245 gHC_ORDERING    = mkPrimModule (fsLit "GHC.Ordering")
 246 gHC_GENERICS    = mkPrimModule (fsLit "GHC.Generics")
 247 gHC_BASE        = mkBaseModule (fsLit "GHC.Base")
 248 gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")
 249 gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")
 250 gHC_READ        = mkBaseModule (fsLit "GHC.Read")
 251 gHC_NUM         = mkBaseModule (fsLit "GHC.Num")
 252 gHC_INTEGER     = mkIntegerModule (fsLit "GHC.Integer")
 253 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
 254 gHC_PARR        = mkBaseModule (fsLit "GHC.PArr")
 255 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
 256 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
 257 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
 258 dATA_STRING     = mkBaseModule (fsLit "Data.String")
 259 gHC_PACK        = mkBaseModule (fsLit "GHC.Pack")
 260 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
 261 gHC_IO_BASE     = mkBaseModule (fsLit "GHC.IOBase")
 262 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
 263 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
 264 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
 265 gHC_ADDR        = mkBaseModule (fsLit "GHC.Addr")
 266 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
 267 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
 268 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
 269 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
 270 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
 271 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
 272 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
 273 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
 274 gENERICS        = mkBaseModule (fsLit "Data.Generics.Basics")
 275 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
 276 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
 277 lEX                 = mkBaseModule (fsLit "Text.Read.Lex")
 278 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
 279 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
 280 mONAD           = mkBaseModule (fsLit "Control.Monad")
 281 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
 282 aRROW           = mkBaseModule (fsLit "Control.Arrow")
 283 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
 284 rANDOM          = mkBaseModule (fsLit "System.Random")
 285 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
 286 cONTROL_EXCEPTION = mkBaseModule (fsLit "Control.Exception")
 287
 288 mAIN, rOOT_MAIN :: Module
 289 mAIN            = mkMainModule_ mAIN_NAME
 290 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation
 291
 292         -- The ':xxx' makes a module name that the user can never
 293         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 294         -- module name still starts with a capital letter, which keeps
 295         -- the z-encoded version consistent.
 296 iNTERACTIVE, thFAKE :: Module
 297 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
 298 thFAKE         = mkMainModule (fsLit ":THFake")
 299
 300 pRELUDE_NAME, mAIN_NAME :: ModuleName
 301 pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")
 302 mAIN_NAME      = mkModuleNameFS (fsLit "Main")
 303
 304 mkPrimModule :: FastString -> Module
 305 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
 306
 307 mkIntegerModule :: FastString -> Module
 308 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
 309
 310 mkBaseModule :: FastString -> Module
 311 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
 312
 313 mkBaseModule_ :: ModuleName -> Module
 314 mkBaseModule_ m = mkModule basePackageId m
 315
 316 mkMainModule :: FastString -> Module
 317 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
 318
 319 mkMainModule_ :: ModuleName -> Module
 320 mkMainModule_ m = mkModule mainPackageId m
 321 \end{code}
 322
 323 %************************************************************************
 324 %*                                                                      *
 325 \subsection{Constructing the names of tuples
 326 %*                                                                      *
 327 %************************************************************************
 328
 329 \begin{code}
 330 mkTupleModule :: Boxity -> Arity -> Module
 331 mkTupleModule Boxed   0 = gHC_UNIT
 332 mkTupleModule Boxed   _ = gHC_TUPLE
 333 mkTupleModule Unboxed _ = gHC_PRIM
 334 \end{code}
 335
 336
 337 %************************************************************************
 338 %*                                                                      *
 339                         RdrNames
 340 %*                                                                      *
 341 %************************************************************************
 342
 343 \begin{code}
 344 main_RDR_Unqual    :: RdrName
 345 main_RDR_Unqual = mkUnqual varName (fsLit "main")
 346         -- We definitely don't want an Orig RdrName, because
 347         -- main might, in principle, be imported into module Main
 348
 349 forall_tv_RDR, dot_tv_RDR :: RdrName
 350 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
 351 dot_tv_RDR    = mkUnqual tvName (fsLit ".")
 352
 353 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
 354     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
 355 eq_RDR                  = nameRdrName eqName
 356 ge_RDR                  = nameRdrName geName
 357 ne_RDR                  = varQual_RDR  gHC_BASE (fsLit "/=")
 358 le_RDR                  = varQual_RDR  gHC_BASE (fsLit "<=")
 359 lt_RDR                  = varQual_RDR  gHC_BASE (fsLit "<")
 360 gt_RDR                  = varQual_RDR  gHC_BASE (fsLit ">")
 361 compare_RDR             = varQual_RDR  gHC_BASE (fsLit "compare")
 362 ltTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "LT")
 363 eqTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "EQ")
 364 gtTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "GT")
 365
 366 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
 367     :: RdrName
 368 eqClass_RDR             = nameRdrName eqClassName
 369 numClass_RDR            = nameRdrName numClassName
 370 ordClass_RDR            = nameRdrName ordClassName
 371 enumClass_RDR           = nameRdrName enumClassName
 372 monadClass_RDR          = nameRdrName monadClassName
 373
 374 map_RDR, append_RDR :: RdrName
 375 map_RDR                 = varQual_RDR gHC_BASE (fsLit "map")
 376 append_RDR              = varQual_RDR gHC_BASE (fsLit "++")
 377
 378 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
 379 foldr_RDR               = nameRdrName foldrName
 380 build_RDR               = nameRdrName buildName
 381 returnM_RDR             = nameRdrName returnMName
 382 bindM_RDR               = nameRdrName bindMName
 383 failM_RDR               = nameRdrName failMName
 384
 385 and_RDR :: RdrName
 386 and_RDR                 = nameRdrName andName
 387
 388 left_RDR, right_RDR :: RdrName
 389 left_RDR                = nameRdrName leftDataConName
 390 right_RDR               = nameRdrName rightDataConName
 391
 392 fromEnum_RDR, toEnum_RDR :: RdrName
 393 fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")
 394 toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")
 395
 396 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
 397 enumFrom_RDR            = nameRdrName enumFromName
 398 enumFromTo_RDR          = nameRdrName enumFromToName
 399 enumFromThen_RDR        = nameRdrName enumFromThenName
 400 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 401
 402 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
 403 ratioDataCon_RDR        = nameRdrName ratioDataConName
 404 plusInteger_RDR         = nameRdrName plusIntegerName
 405 timesInteger_RDR        = nameRdrName timesIntegerName
 406
 407 ioDataCon_RDR :: RdrName
 408 ioDataCon_RDR           = nameRdrName ioDataConName
 409
 410 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
 411     unpackCStringUtf8_RDR :: RdrName
 412 eqString_RDR            = nameRdrName eqStringName
 413 unpackCString_RDR       = nameRdrName unpackCStringName
 414 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 415 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 416
 417 newStablePtr_RDR, wordDataCon_RDR :: RdrName
 418 newStablePtr_RDR        = nameRdrName newStablePtrName
 419 wordDataCon_RDR         = dataQual_RDR gHC_WORD (fsLit "W#")
 420
 421 bindIO_RDR, returnIO_RDR :: RdrName
 422 bindIO_RDR              = nameRdrName bindIOName
 423 returnIO_RDR            = nameRdrName returnIOName
 424
 425 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
 426 fromInteger_RDR         = nameRdrName fromIntegerName
 427 fromRational_RDR        = nameRdrName fromRationalName
 428 minus_RDR               = nameRdrName minusName
 429 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
 430 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
 431
 432 fromString_RDR :: RdrName
 433 fromString_RDR          = nameRdrName fromStringName
 434
 435 compose_RDR :: RdrName
 436 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
 437
 438 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
 439     range_RDR, inRange_RDR, index_RDR,
 440     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
 441 not_RDR                 = varQual_RDR gHC_BASE (fsLit "not")
 442 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
 443 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
 444 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
 445 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
 446 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
 447 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
 448 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
 449 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
 450 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
 451 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
 452
 453 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
 454     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
 455 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
 456 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
 457 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
 458 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
 459 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
 460 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
 461 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
 462 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
 463
 464 punc_RDR, ident_RDR, symbol_RDR :: RdrName
 465 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
 466 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
 467 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
 468
 469 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
 470 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
 471 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")
 472 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
 473 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
 474
 475 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
 476     showSpace_RDR, showParen_RDR :: RdrName
 477 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
 478 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
 479 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")
 480 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
 481 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")
 482 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")
 483
 484 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
 485 typeOf_RDR     = varQual_RDR tYPEABLE (fsLit "typeOf")
 486 mkTypeRep_RDR  = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
 487 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
 488
 489 undefined_RDR :: RdrName
 490 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
 491
 492 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
 493 crossDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
 494 inlDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inl")
 495 inrDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inr")
 496 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
 497
 498 ----------------------
 499 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
 500     :: Module -> FastString -> RdrName
 501 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
 502 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
 503 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
 504 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
 505 \end{code}
 506
 507 %************************************************************************
 508 %*                                                                      *
 509 \subsection{Known-key names}
 510 %*                                                                      *
 511 %************************************************************************
 512
 513 Many of these Names are not really "built in", but some parts of the
 514 compiler (notably the deriving mechanism) need to mention their names,
 515 and it's convenient to write them all down in one place.
 516
 517 --MetaHaskell Extension  add the constrs and the lower case case
 518 -- guys as well (perhaps) e.g. see  trueDataConName     below
 519
 520
 521 \begin{code}
 522 runMainIOName :: Name
 523 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
 524
 525 orderingTyConName :: Name
 526 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
 527
 528 eitherTyConName, leftDataConName, rightDataConName :: Name
 529 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
 530 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
 531 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
 532
 533 -- Generics
 534 crossTyConName, plusTyConName, genUnitTyConName :: Name
 535 crossTyConName     = tcQual   gHC_GENERICS (fsLit ":*:") crossTyConKey
 536 plusTyConName      = tcQual   gHC_GENERICS (fsLit ":+:") plusTyConKey
 537 genUnitTyConName   = tcQual   gHC_GENERICS (fsLit "Unit") genUnitTyConKey
 538
 539 -- Base strings Strings
 540 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
 541     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
 542 unpackCStringName       = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
 543 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
 544 unpackCStringFoldrName  = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
 545 unpackCStringUtf8Name   = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
 546 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
 547 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
 548
 549 -- The 'inline' function
 550 inlineIdName :: Name
 551 inlineIdName            = varQual gHC_BASE (fsLit "inline") inlineIdKey
 552
 553 -- Base classes (Eq, Ord, Functor)
 554 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
 555 eqClassName       = clsQual  gHC_BASE (fsLit "Eq")      eqClassKey
 556 eqName            = methName gHC_BASE (fsLit "==")      eqClassOpKey
 557 ordClassName      = clsQual  gHC_BASE (fsLit "Ord")     ordClassKey
 558 geName            = methName gHC_BASE (fsLit ">=")      geClassOpKey
 559 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
 560
 561 -- Class Monad
 562 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
 563 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
 564 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
 565 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
 566 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
 567 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
 568
 569 -- Functions for GHC extensions
 570 groupWithName :: Name
 571 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
 572
 573 -- Random PrelBase functions
 574 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
 575     mapName, appendName, andName, orName, assertName,
 576     breakpointName, breakpointCondName, breakpointAutoName,
 577     opaqueTyConName :: Name
 578 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
 579 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
 580 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
 581 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
 582 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
 583 mapName       = varQual gHC_BASE (fsLit "map")        mapIdKey
 584 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
 585 andName           = varQual gHC_BASE (fsLit "&&")        andIdKey
 586 orName            = varQual gHC_BASE (fsLit "||")        orIdKey
 587 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
 588 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
 589 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
 590 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
 591 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
 592
 593 breakpointJumpName :: Name
 594 breakpointJumpName
 595     = mkInternalName
 596         breakpointJumpIdKey
 597         (mkOccNameFS varName (fsLit "breakpointJump"))
 598         noSrcSpan
 599 breakpointCondJumpName :: Name
 600 breakpointCondJumpName
 601     = mkInternalName
 602         breakpointCondJumpIdKey
 603         (mkOccNameFS varName (fsLit "breakpointCondJump"))
 604         noSrcSpan
 605 breakpointAutoJumpName :: Name
 606 breakpointAutoJumpName
 607     = mkInternalName
 608         breakpointAutoJumpIdKey
 609         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
 610         noSrcSpan
 611
 612 -- PrelTup
 613 fstName, sndName :: Name
 614 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
 615 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
 616
 617 -- Module PrelNum
 618 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
 619     timesIntegerName, integerTyConName, smallIntegerName :: Name
 620 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
 621 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
 622 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
 623 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
 624 plusIntegerName   = varQual  gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
 625 timesIntegerName  = varQual  gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
 626 integerTyConName  = tcQual   gHC_INTEGER (fsLit "Integer") integerTyConKey
 627 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
 628
 629 -- PrelReal types and classes
 630 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
 631     integralClassName, realFracClassName, fractionalClassName,
 632     fromRationalName :: Name
 633 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
 634 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
 635 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
 636 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
 637 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
 638 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
 639 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
 640 fromRationalName    = methName gHC_REAL  (fsLit "fromRational") fromRationalClassOpKey
 641
 642 -- PrelFloat classes
 643 floatingClassName, realFloatClassName :: Name
 644 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
 645 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
 646
 647 -- Class Ix
 648 ixClassName :: Name
 649 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
 650
 651 -- Class Typeable
 652 typeableClassName, typeable1ClassName, typeable2ClassName,
 653     typeable3ClassName, typeable4ClassName, typeable5ClassName,
 654     typeable6ClassName, typeable7ClassName :: Name
 655 typeableClassName  = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
 656 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
 657 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
 658 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
 659 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
 660 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
 661 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
 662 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
 663
 664 typeableClassNames :: [Name]
 665 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 666                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 667                         , typeable6ClassName, typeable7ClassName ]
 668
 669 -- Class Data
 670 dataClassName :: Name
 671 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
 672
 673 -- Error module
 674 assertErrorName    :: Name
 675 assertErrorName   = varQual gHC_IO_BASE (fsLit "assertError") assertErrorIdKey
 676
 677 -- Enum module (Enum, Bounded)
 678 enumClassName, enumFromName, enumFromToName, enumFromThenName,
 679     enumFromThenToName, boundedClassName :: Name
 680 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
 681 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
 682 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
 683 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
 684 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
 685 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
 686
 687 -- List functions
 688 concatName, filterName, zipName :: Name
 689 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
 690 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
 691 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
 692
 693 -- Class Show
 694 showClassName :: Name
 695 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
 696
 697 -- Class Read
 698 readClassName :: Name
 699 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
 700
 701 -- parallel array types and functions
 702 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
 703     singletonPName, replicatePName, mapPName, filterPName,
 704     zipPName, crossMapPName, indexPName, toPName, bpermutePName,
 705     bpermuteDftPName, indexOfPName :: Name
 706 enumFromToPName    = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
 707 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
 708 nullPName         = varQual gHC_PARR (fsLit "nullP")             nullPIdKey
 709 lengthPName       = varQual gHC_PARR (fsLit "lengthP")           lengthPIdKey
 710 singletonPName    = varQual gHC_PARR (fsLit "singletonP")         singletonPIdKey
 711 replicatePName    = varQual gHC_PARR (fsLit "replicateP")        replicatePIdKey
 712 mapPName          = varQual gHC_PARR (fsLit "mapP")              mapPIdKey
 713 filterPName       = varQual gHC_PARR (fsLit "filterP")           filterPIdKey
 714 zipPName          = varQual gHC_PARR (fsLit "zipP")              zipPIdKey
 715 crossMapPName     = varQual gHC_PARR (fsLit "crossMapP")         crossMapPIdKey
 716 indexPName        = varQual gHC_PARR (fsLit "!:")                indexPIdKey
 717 toPName           = varQual gHC_PARR (fsLit "toP")               toPIdKey
 718 bpermutePName     = varQual gHC_PARR (fsLit "bpermuteP")    bpermutePIdKey
 719 bpermuteDftPName  = varQual gHC_PARR (fsLit "bpermuteDftP") bpermuteDftPIdKey
 720 indexOfPName      = varQual gHC_PARR (fsLit "indexOfP")     indexOfPIdKey
 721
 722 -- IOBase things
 723 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
 724     failIOName :: Name
 725 ioTyConName       = tcQual  gHC_IO_BASE (fsLit "IO") ioTyConKey
 726 ioDataConName     = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
 727 thenIOName        = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
 728 bindIOName        = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
 729 returnIOName      = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
 730 failIOName        = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
 731
 732 -- IO things
 733 printName :: Name
 734 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
 735
 736 -- Int, Word, and Addr things
 737 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
 738 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
 739 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
 740 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
 741 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
 742
 743 -- Word module
 744 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 745     wordTyConName, wordDataConName :: Name
 746 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
 747 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
 748 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
 749 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
 750 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
 751 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
 752
 753 -- PrelPtr module
 754 ptrTyConName, funPtrTyConName :: Name
 755 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
 756 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
 757
 758 -- Foreign objects and weak pointers
 759 stablePtrTyConName, newStablePtrName :: Name
 760 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
 761 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
 762
 763 -- PrelST module
 764 runSTRepName :: Name
 765 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
 766
 767 -- Recursive-do notation
 768 monadFixClassName, mfixName :: Name
 769 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
 770 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
 771
 772 -- Arrow notation
 773 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
 774 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
 775 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
 776 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
 777 appAName           = varQual aRROW (fsLit "app")          appAIdKey
 778 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
 779 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
 780
 781 -- Other classes, needed for type defaulting
 782 monadPlusClassName, randomClassName, randomGenClassName,
 783     isStringClassName :: Name
 784 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 785 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 786 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 787 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 788
 789 -- dotnet interop
 790 objectTyConName :: Name
 791 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 792         -- objectTyConName was "wTcQual", but that's gone now, and
 793         -- I can't see why it was wired in anyway...
 794 unmarshalObjectName, marshalObjectName, marshalStringName,
 795     unmarshalStringName, checkDotnetResName :: Name
 796 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 797 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 798 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 799 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 800 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 801 \end{code}
 802
 803 %************************************************************************
 804 %*                                                                      *
 805 \subsection{Local helpers}
 806 %*                                                                      *
 807 %************************************************************************
 808
 809 All these are original names; hence mkOrig
 810
 811 \begin{code}
 812 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 813 varQual  = mk_known_key_name varName
 814 tcQual   = mk_known_key_name tcName
 815 clsQual  = mk_known_key_name clsName
 816
 817 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 818 mk_known_key_name space modu str unique
 819   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 820
 821 conName :: Module -> FastString -> Unique -> Name
 822 conName modu occ unique
 823   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
 824
 825 methName :: Module -> FastString -> Unique -> Name
 826 methName modu occ unique
 827   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
 828 \end{code}
 829
 830 %************************************************************************
 831 %*                                                                      *
 832 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 833 %*                                                                      *
 834 %************************************************************************
 835 --MetaHaskell extension hand allocate keys here
 836
 837 \begin{code}
 838 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
 839     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
 840     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
 841     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
 842 boundedClassKey         = mkPreludeClassUnique 1
 843 enumClassKey            = mkPreludeClassUnique 2
 844 eqClassKey              = mkPreludeClassUnique 3
 845 floatingClassKey        = mkPreludeClassUnique 5
 846 fractionalClassKey      = mkPreludeClassUnique 6
 847 integralClassKey        = mkPreludeClassUnique 7
 848 monadClassKey           = mkPreludeClassUnique 8
 849 dataClassKey            = mkPreludeClassUnique 9
 850 functorClassKey         = mkPreludeClassUnique 10
 851 numClassKey             = mkPreludeClassUnique 11
 852 ordClassKey             = mkPreludeClassUnique 12
 853 readClassKey            = mkPreludeClassUnique 13
 854 realClassKey            = mkPreludeClassUnique 14
 855 realFloatClassKey       = mkPreludeClassUnique 15
 856 realFracClassKey        = mkPreludeClassUnique 16
 857 showClassKey            = mkPreludeClassUnique 17
 858 ixClassKey              = mkPreludeClassUnique 18
 859
 860 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
 861     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
 862     :: Unique
 863 typeableClassKey        = mkPreludeClassUnique 20
 864 typeable1ClassKey       = mkPreludeClassUnique 21
 865 typeable2ClassKey       = mkPreludeClassUnique 22
 866 typeable3ClassKey       = mkPreludeClassUnique 23
 867 typeable4ClassKey       = mkPreludeClassUnique 24
 868 typeable5ClassKey       = mkPreludeClassUnique 25
 869 typeable6ClassKey       = mkPreludeClassUnique 26
 870 typeable7ClassKey       = mkPreludeClassUnique 27
 871
 872 monadFixClassKey :: Unique
 873 monadFixClassKey        = mkPreludeClassUnique 28
 874
 875 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
 876 monadPlusClassKey       = mkPreludeClassUnique 30
 877 randomClassKey          = mkPreludeClassUnique 31
 878 randomGenClassKey       = mkPreludeClassUnique 32
 879
 880 isStringClassKey :: Unique
 881 isStringClassKey        = mkPreludeClassUnique 33
 882 \end{code}
 883
 884 %************************************************************************
 885 %*                                                                      *
 886 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 887 %*                                                                      *
 888 %************************************************************************
 889
 890 \begin{code}
 891 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
 892     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
 893     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
 894     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
 895     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
 896     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
 897     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
 898     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
 899     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
 900 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 901 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 902 boolTyConKey                            = mkPreludeTyConUnique  4
 903 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 904 charPrimTyConKey                        = mkPreludeTyConUnique  7
 905 charTyConKey                            = mkPreludeTyConUnique  8
 906 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 907 doubleTyConKey                          = mkPreludeTyConUnique 10
 908 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 909 floatTyConKey                           = mkPreludeTyConUnique 12
 910 funTyConKey                             = mkPreludeTyConUnique 13
 911 intPrimTyConKey                         = mkPreludeTyConUnique 14
 912 intTyConKey                             = mkPreludeTyConUnique 15
 913 int8TyConKey                            = mkPreludeTyConUnique 16
 914 int16TyConKey                           = mkPreludeTyConUnique 17
 915 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 916 int32TyConKey                           = mkPreludeTyConUnique 19
 917 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 918 int64TyConKey                           = mkPreludeTyConUnique 21
 919 integerTyConKey                         = mkPreludeTyConUnique 22
 920 listTyConKey                            = mkPreludeTyConUnique 23
 921 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 922 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 923 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 924 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 925 orderingTyConKey                        = mkPreludeTyConUnique 30
 926 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 927 ratioTyConKey                           = mkPreludeTyConUnique 32
 928 rationalTyConKey                        = mkPreludeTyConUnique 33
 929 realWorldTyConKey                       = mkPreludeTyConUnique 34
 930 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 931 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 932
 933 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
 934 anyPrimTyConKey                         = mkPreludeTyConUnique 37
 935 anyPrimTyCon1Key                        = mkPreludeTyConUnique 38
 936
 937 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
 938     mutVarPrimTyConKey, ioTyConKey,
 939     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
 940     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
 941     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
 942     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
 943     funPtrTyConKey, tVarPrimTyConKey :: Unique
 944 statePrimTyConKey                       = mkPreludeTyConUnique 50
 945 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 946 stableNameTyConKey                      = mkPreludeTyConUnique 52
 947 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 948 ioTyConKey                              = mkPreludeTyConUnique 56
 949 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 950 wordTyConKey                            = mkPreludeTyConUnique 59
 951 word8TyConKey                           = mkPreludeTyConUnique 60
 952 word16TyConKey                          = mkPreludeTyConUnique 61
 953 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 954 word32TyConKey                          = mkPreludeTyConUnique 63
 955 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 956 word64TyConKey                          = mkPreludeTyConUnique 65
 957 liftedConKey                            = mkPreludeTyConUnique 66
 958 unliftedConKey                          = mkPreludeTyConUnique 67
 959 anyBoxConKey                            = mkPreludeTyConUnique 68
 960 kindConKey                              = mkPreludeTyConUnique 69
 961 boxityConKey                            = mkPreludeTyConUnique 70
 962 typeConKey                              = mkPreludeTyConUnique 71
 963 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 964 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 965 ptrTyConKey                             = mkPreludeTyConUnique 74
 966 funPtrTyConKey                          = mkPreludeTyConUnique 75
 967 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
 968
 969 -- Generic Type Constructors
 970 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
 971 crossTyConKey                           = mkPreludeTyConUnique 79
 972 plusTyConKey                            = mkPreludeTyConUnique 80
 973 genUnitTyConKey                         = mkPreludeTyConUnique 81
 974
 975 -- Parallel array type constructor
 976 parrTyConKey :: Unique
 977 parrTyConKey                            = mkPreludeTyConUnique 82
 978
 979 -- dotnet interop
 980 objectTyConKey :: Unique
 981 objectTyConKey                          = mkPreludeTyConUnique 83
 982
 983 eitherTyConKey :: Unique
 984 eitherTyConKey                          = mkPreludeTyConUnique 84
 985
 986 -- Super Kinds constructors
 987 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
 988 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
 989 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
 990
 991 -- Kind constructors
 992 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
 993     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
 994 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
 995 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
 996 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
 997 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
 998 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
 999
1000 -- Coercion constructors
1001 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1002     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1003     :: Unique
1004 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1005 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1006 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1007 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1008 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1009 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1010
1011 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1012     opaqueTyConKey :: Unique
1013 unknownTyConKey                         = mkPreludeTyConUnique 99
1014 unknown1TyConKey                        = mkPreludeTyConUnique 130
1015 unknown2TyConKey                        = mkPreludeTyConUnique 131
1016 unknown3TyConKey                        = mkPreludeTyConUnique 132
1017 opaqueTyConKey                          = mkPreludeTyConUnique 133
1018
1019 stringTyConKey :: Unique
1020 stringTyConKey                          = mkPreludeTyConUnique 134
1021
1022 ---------------- Template Haskell -------------------
1023 --      USES TyConUniques 100-129
1024 -----------------------------------------------------
1025
1026 unitTyConKey :: Unique
1027 unitTyConKey = mkTupleTyConUnique Boxed 0
1028 \end{code}
1029
1030 %************************************************************************
1031 %*                                                                      *
1032 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1033 %*                                                                      *
1034 %************************************************************************
1035
1036 \begin{code}
1037 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1038     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1039     stableNameDataConKey, trueDataConKey, wordDataConKey,
1040     ioDataConKey :: Unique
1041 charDataConKey                          = mkPreludeDataConUnique  1
1042 consDataConKey                          = mkPreludeDataConUnique  2
1043 doubleDataConKey                        = mkPreludeDataConUnique  3
1044 falseDataConKey                         = mkPreludeDataConUnique  4
1045 floatDataConKey                         = mkPreludeDataConUnique  5
1046 intDataConKey                           = mkPreludeDataConUnique  6
1047 nilDataConKey                           = mkPreludeDataConUnique 11
1048 ratioDataConKey                         = mkPreludeDataConUnique 12
1049 stableNameDataConKey                    = mkPreludeDataConUnique 14
1050 trueDataConKey                          = mkPreludeDataConUnique 15
1051 wordDataConKey                          = mkPreludeDataConUnique 16
1052 ioDataConKey                            = mkPreludeDataConUnique 17
1053
1054 -- Generic data constructors
1055 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1056 crossDataConKey                         = mkPreludeDataConUnique 20
1057 inlDataConKey                           = mkPreludeDataConUnique 21
1058 inrDataConKey                           = mkPreludeDataConUnique 22
1059 genUnitDataConKey                       = mkPreludeDataConUnique 23
1060
1061 -- Data constructor for parallel arrays
1062 parrDataConKey :: Unique
1063 parrDataConKey                          = mkPreludeDataConUnique 24
1064
1065 leftDataConKey, rightDataConKey :: Unique
1066 leftDataConKey                          = mkPreludeDataConUnique 25
1067 rightDataConKey                         = mkPreludeDataConUnique 26
1068 \end{code}
1069
1070 %************************************************************************
1071 %*                                                                      *
1072 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1073 %*                                                                      *
1074 %************************************************************************
1075
1076 \begin{code}
1077 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1078     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1079     integerMinusOneIdKey, integerPlusOneIdKey,
1080     integerPlusTwoIdKey, integerZeroIdKey,
1081     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1082     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1083     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1084     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1085     traceIdKey,
1086     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1087     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1088 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1089 augmentIdKey                  = mkPreludeMiscIdUnique  3
1090 appendIdKey                   = mkPreludeMiscIdUnique  4
1091 buildIdKey                    = mkPreludeMiscIdUnique  5
1092 errorIdKey                    = mkPreludeMiscIdUnique  6
1093 foldlIdKey                    = mkPreludeMiscIdUnique  7
1094 foldrIdKey                    = mkPreludeMiscIdUnique  8
1095 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1096 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1097 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1098 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1099 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1100 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1101 seqIdKey                      = mkPreludeMiscIdUnique 15
1102 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1103 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1104 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1105 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1106 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1107 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1108 parIdKey                      = mkPreludeMiscIdUnique 22
1109 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1110 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1111 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1112 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1113 traceIdKey                    = mkPreludeMiscIdUnique 27
1114 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1115 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1116 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1117 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1118
1119 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1120     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1121     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1122     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1123     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1124 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1125 concatIdKey                   = mkPreludeMiscIdUnique 33
1126 filterIdKey                   = mkPreludeMiscIdUnique 34
1127 zipIdKey                      = mkPreludeMiscIdUnique 35
1128 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1129 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1130 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1131 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1132 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1133 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1134 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1135 printIdKey                    = mkPreludeMiscIdUnique 43
1136 failIOIdKey                   = mkPreludeMiscIdUnique 44
1137 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1138 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1139 fstIdKey                      = mkPreludeMiscIdUnique 49
1140 sndIdKey                      = mkPreludeMiscIdUnique 50
1141 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1142 assertIdKey                   = mkPreludeMiscIdUnique 53
1143 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1144
1145 rootMainKey, runMainKey :: Unique
1146 rootMainKey                   = mkPreludeMiscIdUnique 55
1147 runMainKey                    = mkPreludeMiscIdUnique 56
1148
1149 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1150 andIdKey                      = mkPreludeMiscIdUnique 57
1151 orIdKey                       = mkPreludeMiscIdUnique 58
1152 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1153 lazyIdKey                     = mkPreludeMiscIdUnique 60
1154 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1155
1156 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1157     breakpointJumpIdKey, breakpointCondJumpIdKey,
1158     breakpointAutoJumpIdKey :: Unique
1159 breakpointIdKey               = mkPreludeMiscIdUnique 62
1160 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1161 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1162 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1163 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1164 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1165
1166 inlineIdKey :: Unique
1167 inlineIdKey                   = mkPreludeMiscIdUnique 68
1168
1169 mapIdKey, groupWithIdKey :: Unique
1170 mapIdKey                      = mkPreludeMiscIdUnique 69
1171 groupWithIdKey        = mkPreludeMiscIdUnique 70
1172
1173 -- Parallel array functions
1174 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1175     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1176     enumFromToPIdKey, enumFromThenToPIdKey,
1177     bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique
1178 singletonPIdKey               = mkPreludeMiscIdUnique 79
1179 nullPIdKey                    = mkPreludeMiscIdUnique 80
1180 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1181 replicatePIdKey               = mkPreludeMiscIdUnique 82
1182 mapPIdKey                     = mkPreludeMiscIdUnique 83
1183 filterPIdKey                  = mkPreludeMiscIdUnique 84
1184 zipPIdKey                     = mkPreludeMiscIdUnique 85
1185 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1186 indexPIdKey                   = mkPreludeMiscIdUnique 87
1187 toPIdKey                      = mkPreludeMiscIdUnique 88
1188 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1189 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1190 bpermutePIdKey                = mkPreludeMiscIdUnique 91
1191 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
1192 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
1193
1194 -- dotnet interop
1195 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1196     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1197 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1198 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1199 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1200 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1201 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1202
1203 \end{code}
1204
1205 Certain class operations from Prelude classes.  They get their own
1206 uniques so we can look them up easily when we want to conjure them up
1207 during type checking.
1208
1209 \begin{code}
1210         -- Just a place holder for  unbound variables  produced by the renamer:
1211 unboundKey :: Unique
1212 unboundKey                    = mkPreludeMiscIdUnique 101
1213
1214 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1215     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1216     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1217     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1218     :: Unique
1219 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1220 minusClassOpKey               = mkPreludeMiscIdUnique 103
1221 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1222 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1223 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1224 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1225 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1226 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1227 geClassOpKey                  = mkPreludeMiscIdUnique 110
1228 negateClassOpKey              = mkPreludeMiscIdUnique 111
1229 failMClassOpKey               = mkPreludeMiscIdUnique 112
1230 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1231 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1232 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1233
1234 -- Recursive do notation
1235 mfixIdKey :: Unique
1236 mfixIdKey       = mkPreludeMiscIdUnique 118
1237
1238 -- Arrow notation
1239 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1240     loopAIdKey :: Unique
1241 arrAIdKey       = mkPreludeMiscIdUnique 119
1242 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1243 firstAIdKey     = mkPreludeMiscIdUnique 121
1244 appAIdKey       = mkPreludeMiscIdUnique 122
1245 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1246 loopAIdKey      = mkPreludeMiscIdUnique 124
1247
1248 fromStringClassOpKey :: Unique
1249 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1250
1251 ---------------- Template Haskell -------------------
1252 --      USES IdUniques 200-399
1253 -----------------------------------------------------
1254 \end{code}
1255
1256
1257 %************************************************************************
1258 %*                                                                      *
1259 \subsection{Standard groups of types}
1260 %*                                                                      *
1261 %************************************************************************
1262
1263 \begin{code}
1264 numericTyKeys :: [Unique]
1265 numericTyKeys =
1266         [ wordTyConKey
1267         , intTyConKey
1268         , integerTyConKey
1269         , doubleTyConKey
1270         , floatTyConKey
1271         ]
1272 \end{code}
1273
1274
1275 %************************************************************************
1276 %*                                                                      *
1277 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1278 %*                                                                      *
1279 %************************************************************************
1280
1281 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1282 even though every numeric class has these two as a superclass,
1283 because the list of ambiguous dictionaries hasn't been simplified.
1284
1285 \begin{code}
1286 numericClassKeys :: [Unique]
1287 numericClassKeys =
1288         [ numClassKey
1289         , realClassKey
1290         , integralClassKey
1291         ]
1292         ++ fractionalClassKeys
1293
1294 fractionalClassKeys :: [Unique]
1295 fractionalClassKeys =
1296         [ fractionalClassKey
1297         , floatingClassKey
1298         , realFracClassKey
1299         , realFloatClassKey
1300         ]
1301
1302         -- the strictness analyser needs to know about numeric types
1303         -- (see SaAbsInt.lhs)
1304 needsDataDeclCtxtClassKeys :: [Unique]
1305 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1306         [ readClassKey
1307         ]
1308
1309 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1310 -- and are: "classes defined in the Prelude or a standard library"
1311 standardClassKeys :: [Unique]
1312 standardClassKeys = derivableClassKeys ++ numericClassKeys
1313                   ++ [randomClassKey, randomGenClassKey,
1314                       functorClassKey,
1315                       monadClassKey, monadPlusClassKey,
1316                       isStringClassKey
1317                      ]
1318 \end{code}
1319
1320 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1321 (@TcDeriv@).
1322
1323 \begin{code}
1324 derivableClassKeys :: [Unique]
1325 derivableClassKeys
1326   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1327       boundedClassKey, showClassKey, readClassKey ]
1328 \end{code}
1329