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