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, mkSystemVarName )
  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 association 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 The names for DPH can come from one of multiple backend packages. At the point where
 102 'basicKnownKeyNames' is used, we don't know which backend it will be.  Hence, we list
 103 the names for multiple backends.  That works out fine, although they use the same uniques,
 104 as we are guaranteed to only load one backend; hence, only one of the different names
 105 sharing a unique will be used.
 106
 107 \begin{code}
 108 basicKnownKeyNames :: [Name]
 109 basicKnownKeyNames
 110  = genericTyConNames
 111  ++ typeableClassNames
 112  ++ dphKnownKeyNames dphSeqPackageId ++ dphKnownKeyNames dphParPackageId
 113  ++ [   -- Type constructors (synonyms especially)
 114         ioTyConName, ioDataConName,
 115         runMainIOName,
 116         orderingTyConName,
 117         rationalTyConName,
 118         stringTyConName,
 119         ratioDataConName,
 120         ratioTyConName,
 121         integerTyConName, smallIntegerName,
 122
 123         --  Classes.  *Must* include:
 124         --      classes that are grabbed by key (e.g., eqClassKey)
 125         --      classes in "Class.standardClassKeys" (quite a few)
 126         eqClassName,                    -- mentioned, derivable
 127         ordClassName,                   -- derivable
 128         boundedClassName,               -- derivable
 129         numClassName,                   -- mentioned, numeric
 130         enumClassName,                  -- derivable
 131         monadClassName,
 132         functorClassName,
 133         realClassName,                  -- numeric
 134         integralClassName,              -- numeric
 135         fractionalClassName,            -- numeric
 136         floatingClassName,              -- numeric
 137         realFracClassName,              -- numeric
 138         realFloatClassName,             -- numeric
 139         dataClassName,
 140         isStringClassName,
 141         applicativeClassName,
 142         foldableClassName,
 143         traversableClassName,
 144
 145         -- Numeric stuff
 146         negateName, minusName, geName, eqName,
 147
 148         -- Conversion functions
 149         fromRationalName, fromIntegerName,
 150         toIntegerName, toRationalName,
 151         fromIntegralName, realToFracName,
 152
 153         -- String stuff
 154         fromStringName,
 155
 156         -- Enum stuff
 157         enumFromName, enumFromThenName,
 158         enumFromThenToName, enumFromToName,
 159
 160         -- Monad stuff
 161         thenIOName, bindIOName, returnIOName, failIOName,
 162         failMName, bindMName, thenMName, returnMName,
 163         fmapName,
 164
 165         -- MonadRec stuff
 166         mfixName,
 167
 168         -- Arrow stuff
 169         arrAName, composeAName, firstAName,
 170         appAName, choiceAName, loopAName,
 171
 172         -- Ix stuff
 173         ixClassName,
 174
 175         -- Show stuff
 176         showClassName,
 177
 178         -- Read stuff
 179         readClassName,
 180
 181         -- Stable pointers
 182         newStablePtrName,
 183
 184     -- GHC Extensions
 185         groupWithName,
 186
 187         -- Strings and lists
 188         unpackCStringName, unpackCStringAppendName,
 189         unpackCStringFoldrName, unpackCStringUtf8Name,
 190
 191         -- List operations
 192         concatName, filterName, mapName,
 193         zipName, foldrName, buildName, augmentName, appendName,
 194
 195         dollarName,         -- The ($) apply function
 196
 197         -- FFI primitive types that are not wired-in.
 198         stablePtrTyConName, ptrTyConName, funPtrTyConName,
 199         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
 200         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 201
 202         -- Others
 203         otherwiseIdName, inlineIdName,
 204         plusIntegerName, timesIntegerName,
 205         eqStringName, assertName, breakpointName, breakpointCondName,
 206         breakpointAutoName,  opaqueTyConName,
 207         assertErrorName, runSTRepName,
 208         printName, fstName, sndName,
 209
 210         -- MonadFix
 211         monadFixClassName, mfixName,
 212
 213         -- Other classes
 214         randomClassName, randomGenClassName, monadPlusClassName,
 215
 216         -- Annotation type checking
 217         toAnnotationWrapperName
 218
 219         -- The Either type
 220         , eitherTyConName, leftDataConName, rightDataConName
 221
 222         -- dotnet interop
 223         , objectTyConName, marshalObjectName, unmarshalObjectName
 224         , marshalStringName, unmarshalStringName, checkDotnetResName
 225
 226         -- Generics
 227         , genClassName, gen1ClassName
 228         , datatypeClassName, constructorClassName, selectorClassName
 229
 230         -- Monad comprehensions
 231         , guardMName
 232         , liftMName
 233         , groupMName
 234         , mzipName
 235     ]
 236
 237 genericTyConNames :: [Name]
 238 genericTyConNames = [
 239     v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
 240     k1TyConName, m1TyConName, sumTyConName, prodTyConName,
 241     compTyConName, rTyConName, pTyConName, dTyConName,
 242     cTyConName, sTyConName, rec0TyConName, par0TyConName,
 243     d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
 244     repTyConName, rep1TyConName
 245   ]
 246
 247 -- Know names from the DPH package which vary depending on the selected DPH backend.
 248 --
 249 dphKnownKeyNames :: PackageId -> [Name]
 250 dphKnownKeyNames dphPkg
 251   = map ($ dphPkg)
 252     [
 253         -- Parallel array operations
 254           nullPName, lengthPName, replicatePName,       singletonPName, mapPName,
 255           filterPName, zipPName, crossMapPName, indexPName,
 256           toPName, emptyPName, appPName,
 257         enumFromToPName, enumFromThenToPName
 258
 259     ]
 260 \end{code}
 261
 262
 263 %************************************************************************
 264 %*                                                                      *
 265 \subsection{Module names}
 266 %*                                                                      *
 267 %************************************************************************
 268
 269
 270 --MetaHaskell Extension Add a new module here
 271 \begin{code}
 272 pRELUDE :: Module
 273 pRELUDE         = mkBaseModule_ pRELUDE_NAME
 274
 275 gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
 276     gHC_MAGIC,
 277     gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_CSTRING,
 278     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
 279     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
 280     gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
 281     gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
 282     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
 283     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_GROUP, mONAD_ZIP,
 284     aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
 285     cONTROL_EXCEPTION_BASE :: Module
 286
 287 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
 288 gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")
 289 gHC_UNIT        = mkPrimModule (fsLit "GHC.Unit")
 290 gHC_ORDERING    = mkPrimModule (fsLit "GHC.Ordering")
 291 gHC_GENERICS    = mkPrimModule (fsLit "GHC.Generics")
 292 gHC_MAGIC       = mkPrimModule (fsLit "GHC.Magic")
 293 gHC_CSTRING     = mkPrimModule (fsLit "GHC.CString")
 294
 295 gHC_CLASSES     = mkBaseModule (fsLit "GHC.Classes")
 296 gHC_BASE        = mkBaseModule (fsLit "GHC.Base")
 297 gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")
 298 gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")
 299 gHC_READ        = mkBaseModule (fsLit "GHC.Read")
 300 gHC_NUM         = mkBaseModule (fsLit "GHC.Num")
 301 gHC_INTEGER     = mkIntegerModule (fsLit "GHC.Integer")
 302 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
 303 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
 304 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
 305 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
 306 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
 307 dATA_STRING     = mkBaseModule (fsLit "Data.String")
 308 dATA_FOLDABLE   = mkBaseModule (fsLit "Data.Foldable")
 309 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
 310 gHC_PACK        = mkBaseModule (fsLit "GHC.Pack")
 311 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
 312 gHC_IO          = mkBaseModule (fsLit "GHC.IO")
 313 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
 314 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
 315 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
 316 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
 317 gHC_ADDR        = mkBaseModule (fsLit "GHC.Addr")
 318 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
 319 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
 320 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
 321 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
 322 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
 323 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
 324 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
 325 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
 326 gENERICS        = mkBaseModule (fsLit "Data.Data")
 327 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
 328 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
 329 lEX             = mkBaseModule (fsLit "Text.Read.Lex")
 330 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
 331 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
 332 mONAD           = mkBaseModule (fsLit "Control.Monad")
 333 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
 334 mONAD_GROUP     = mkBaseModule (fsLit "Control.Monad.Group")
 335 mONAD_ZIP       = mkBaseModule (fsLit "Control.Monad.Zip")
 336 aRROW           = mkBaseModule (fsLit "Control.Arrow")
 337 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
 338 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
 339 rANDOM          = mkBaseModule (fsLit "System.Random")
 340 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
 341 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
 342
 343 gHC_PARR :: PackageId -> Module
 344 gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
 345
 346 gHC_PARR' :: Module
 347 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
 348
 349 mAIN, rOOT_MAIN :: Module
 350 mAIN            = mkMainModule_ mAIN_NAME
 351 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation
 352
 353         -- The ':xxx' makes a module name that the user can never
 354         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 355         -- module name still starts with a capital letter, which keeps
 356         -- the z-encoded version consistent.
 357 iNTERACTIVE :: Module
 358 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
 359
 360 pRELUDE_NAME, mAIN_NAME :: ModuleName
 361 pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")
 362 mAIN_NAME      = mkModuleNameFS (fsLit "Main")
 363
 364 mkPrimModule :: FastString -> Module
 365 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
 366
 367 mkIntegerModule :: FastString -> Module
 368 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
 369
 370 mkBaseModule :: FastString -> Module
 371 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
 372
 373 mkBaseModule_ :: ModuleName -> Module
 374 mkBaseModule_ m = mkModule basePackageId m
 375
 376 mkMainModule :: FastString -> Module
 377 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
 378
 379 mkMainModule_ :: ModuleName -> Module
 380 mkMainModule_ m = mkModule mainPackageId m
 381 \end{code}
 382
 383 %************************************************************************
 384 %*                                                                      *
 385 \subsection{Constructing the names of tuples
 386 %*                                                                      *
 387 %************************************************************************
 388
 389 \begin{code}
 390 mkTupleModule :: Boxity -> Arity -> Module
 391 mkTupleModule Boxed   0 = gHC_UNIT
 392 mkTupleModule Boxed   _ = gHC_TUPLE
 393 mkTupleModule Unboxed _ = gHC_PRIM
 394 \end{code}
 395
 396
 397 %************************************************************************
 398 %*                                                                      *
 399                         RdrNames
 400 %*                                                                      *
 401 %************************************************************************
 402
 403 \begin{code}
 404 main_RDR_Unqual    :: RdrName
 405 main_RDR_Unqual = mkUnqual varName (fsLit "main")
 406         -- We definitely don't want an Orig RdrName, because
 407         -- main might, in principle, be imported into module Main
 408
 409 forall_tv_RDR, dot_tv_RDR :: RdrName
 410 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
 411 dot_tv_RDR    = mkUnqual tvName (fsLit ".")
 412
 413 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
 414     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
 415 eq_RDR                  = nameRdrName eqName
 416 ge_RDR                  = nameRdrName geName
 417 ne_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "/=")
 418 le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=")
 419 lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<")
 420 gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")
 421 compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare")
 422 ltTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "LT")
 423 eqTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "EQ")
 424 gtTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "GT")
 425
 426 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
 427     :: RdrName
 428 eqClass_RDR             = nameRdrName eqClassName
 429 numClass_RDR            = nameRdrName numClassName
 430 ordClass_RDR            = nameRdrName ordClassName
 431 enumClass_RDR           = nameRdrName enumClassName
 432 monadClass_RDR          = nameRdrName monadClassName
 433
 434 map_RDR, append_RDR :: RdrName
 435 map_RDR                 = varQual_RDR gHC_BASE (fsLit "map")
 436 append_RDR              = varQual_RDR gHC_BASE (fsLit "++")
 437
 438 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
 439 foldr_RDR               = nameRdrName foldrName
 440 build_RDR               = nameRdrName buildName
 441 returnM_RDR             = nameRdrName returnMName
 442 bindM_RDR               = nameRdrName bindMName
 443 failM_RDR               = nameRdrName failMName
 444
 445 left_RDR, right_RDR :: RdrName
 446 left_RDR                = nameRdrName leftDataConName
 447 right_RDR               = nameRdrName rightDataConName
 448
 449 fromEnum_RDR, toEnum_RDR :: RdrName
 450 fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")
 451 toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")
 452
 453 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
 454 enumFrom_RDR            = nameRdrName enumFromName
 455 enumFromTo_RDR          = nameRdrName enumFromToName
 456 enumFromThen_RDR        = nameRdrName enumFromThenName
 457 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 458
 459 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
 460 ratioDataCon_RDR        = nameRdrName ratioDataConName
 461 plusInteger_RDR         = nameRdrName plusIntegerName
 462 timesInteger_RDR        = nameRdrName timesIntegerName
 463
 464 ioDataCon_RDR :: RdrName
 465 ioDataCon_RDR           = nameRdrName ioDataConName
 466
 467 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
 468     unpackCStringUtf8_RDR :: RdrName
 469 eqString_RDR            = nameRdrName eqStringName
 470 unpackCString_RDR       = nameRdrName unpackCStringName
 471 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 472 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 473
 474 newStablePtr_RDR, wordDataCon_RDR :: RdrName
 475 newStablePtr_RDR        = nameRdrName newStablePtrName
 476 wordDataCon_RDR         = dataQual_RDR gHC_WORD (fsLit "W#")
 477
 478 bindIO_RDR, returnIO_RDR :: RdrName
 479 bindIO_RDR              = nameRdrName bindIOName
 480 returnIO_RDR            = nameRdrName returnIOName
 481
 482 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
 483 fromInteger_RDR         = nameRdrName fromIntegerName
 484 fromRational_RDR        = nameRdrName fromRationalName
 485 minus_RDR               = nameRdrName minusName
 486 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
 487 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
 488
 489 fromString_RDR :: RdrName
 490 fromString_RDR          = nameRdrName fromStringName
 491
 492 compose_RDR :: RdrName
 493 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
 494
 495 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
 496     and_RDR, range_RDR, inRange_RDR, index_RDR,
 497     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
 498 and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")
 499 not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")
 500 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
 501 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
 502 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
 503 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
 504 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
 505 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
 506 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
 507 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
 508 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
 509 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
 510
 511 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
 512     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
 513 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
 514 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
 515 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
 516 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
 517 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
 518 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
 519 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
 520 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
 521
 522 punc_RDR, ident_RDR, symbol_RDR :: RdrName
 523 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
 524 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
 525 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
 526
 527 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
 528 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
 529 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")
 530 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
 531 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
 532
 533 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
 534     showSpace_RDR, showParen_RDR :: RdrName
 535 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
 536 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
 537 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")
 538 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
 539 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")
 540 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")
 541
 542 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
 543 typeOf_RDR     = varQual_RDR tYPEABLE (fsLit "typeOf")
 544 mkTypeRep_RDR  = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
 545 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
 546
 547 undefined_RDR :: RdrName
 548 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
 549
 550 error_RDR :: RdrName
 551 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
 552
 553 -- Old Generics (constructors and functions)
 554 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
 555 crossDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
 556 inlDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inl")
 557 inrDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inr")
 558 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
 559
 560 -- Generics (constructors and functions)
 561 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
 562   k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
 563   prodDataCon_RDR, comp1DataCon_RDR, from_RDR, from1_RDR,
 564   to_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR,
 565   conFixity_RDR, conIsRecord_RDR,
 566   noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
 567   prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
 568   rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
 569
 570 u1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "U1")
 571 par1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Par1")
 572 rec1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
 573 k1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "K1")
 574 m1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "M1")
 575
 576 l1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "L1")
 577 r1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "R1")
 578
 579 prodDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
 580 comp1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
 581
 582 from_RDR  = varQual_RDR gHC_GENERICS (fsLit "from")
 583 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
 584 to_RDR    = varQual_RDR gHC_GENERICS (fsLit "to")
 585 to1_RDR   = varQual_RDR gHC_GENERICS (fsLit "to1")
 586
 587 datatypeName_RDR  = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
 588 moduleName_RDR    = varQual_RDR gHC_GENERICS (fsLit "moduleName")
 589 selName_RDR       = varQual_RDR gHC_GENERICS (fsLit "selName")
 590 conName_RDR       = varQual_RDR gHC_GENERICS (fsLit "conName")
 591 conFixity_RDR     = varQual_RDR gHC_GENERICS (fsLit "conFixity")
 592 conIsRecord_RDR   = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
 593
 594 noArityDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
 595 arityDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Arity")
 596 prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
 597 infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")
 598 leftAssocDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
 599 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
 600 notAssocDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
 601
 602
 603 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
 604 fmap_RDR                = varQual_RDR gHC_BASE (fsLit "fmap")
 605 pure_RDR                = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
 606 ap_RDR                  = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
 607 foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")
 608 traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")
 609
 610 ----------------------
 611 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
 612     :: Module -> FastString -> RdrName
 613 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
 614 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
 615 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
 616 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
 617 \end{code}
 618
 619 %************************************************************************
 620 %*                                                                      *
 621 \subsection{Known-key names}
 622 %*                                                                      *
 623 %************************************************************************
 624
 625 Many of these Names are not really "built in", but some parts of the
 626 compiler (notably the deriving mechanism) need to mention their names,
 627 and it's convenient to write them all down in one place.
 628
 629 --MetaHaskell Extension  add the constrs and the lower case case
 630 -- guys as well (perhaps) e.g. see  trueDataConName     below
 631
 632
 633 \begin{code}
 634 wildCardName :: Name
 635 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
 636
 637 runMainIOName :: Name
 638 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
 639
 640 orderingTyConName :: Name
 641 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
 642
 643 eitherTyConName, leftDataConName, rightDataConName :: Name
 644 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
 645 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
 646 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
 647
 648 -- Generics (types)
 649 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
 650   k1TyConName, m1TyConName, sumTyConName, prodTyConName,
 651   compTyConName, rTyConName, pTyConName, dTyConName,
 652   cTyConName, sTyConName, rec0TyConName, par0TyConName,
 653   d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
 654   repTyConName, rep1TyConName :: Name
 655
 656 v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
 657 u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
 658 par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
 659 rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
 660 k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
 661 m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
 662
 663 sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
 664 prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
 665 compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
 666
 667 rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey
 668 pTyConName  = tcQual gHC_GENERICS (fsLit "P") pTyConKey
 669 dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey
 670 cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey
 671 sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey
 672
 673 rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
 674 par0TyConName  = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
 675 d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
 676 c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
 677 s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
 678 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
 679
 680 repTyConName  = tcQual gHC_GENERICS (fsLit "Rep")  repTyConKey
 681 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
 682
 683 -- Base strings Strings
 684 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
 685     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
 686 unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
 687 unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
 688 unpackCStringFoldrName  = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
 689 unpackCStringUtf8Name   = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
 690 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
 691 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
 692
 693 -- The 'inline' function
 694 inlineIdName :: Name
 695 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
 696
 697 -- Base classes (Eq, Ord, Functor)
 698 fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
 699 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
 700 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
 701 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
 702 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
 703 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
 704 fmapName          = methName gHC_BASE (fsLit "fmap")    fmapClassOpKey
 705
 706 -- Class Monad
 707 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
 708 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
 709 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
 710 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
 711 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
 712 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
 713
 714 -- Classes (Applicative, Foldable, Traversable)
 715 applicativeClassName, foldableClassName, traversableClassName :: Name
 716 applicativeClassName  = clsQual  cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
 717 foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey
 718 traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey
 719
 720 -- Functions for GHC extensions
 721 groupWithName :: Name
 722 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
 723
 724 -- Random PrelBase functions
 725 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
 726     mapName, appendName, assertName,
 727     breakpointName, breakpointCondName, breakpointAutoName,
 728     dollarName, opaqueTyConName :: Name
 729 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
 730 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
 731 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
 732 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
 733 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
 734 mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey
 735 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
 736 dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey
 737 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
 738 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
 739 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
 740 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
 741 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
 742
 743 breakpointJumpName :: Name
 744 breakpointJumpName
 745     = mkInternalName
 746         breakpointJumpIdKey
 747         (mkOccNameFS varName (fsLit "breakpointJump"))
 748         noSrcSpan
 749 breakpointCondJumpName :: Name
 750 breakpointCondJumpName
 751     = mkInternalName
 752         breakpointCondJumpIdKey
 753         (mkOccNameFS varName (fsLit "breakpointCondJump"))
 754         noSrcSpan
 755 breakpointAutoJumpName :: Name
 756 breakpointAutoJumpName
 757     = mkInternalName
 758         breakpointAutoJumpIdKey
 759         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
 760         noSrcSpan
 761
 762 -- PrelTup
 763 fstName, sndName :: Name
 764 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
 765 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
 766
 767 -- Module GHC.Num
 768 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
 769     timesIntegerName,
 770     integerTyConName, smallIntegerName :: Name
 771 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
 772 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
 773 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
 774 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
 775 plusIntegerName   = varQual  gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
 776 timesIntegerName  = varQual  gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
 777 integerTyConName  = tcQual   gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
 778 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
 779
 780 -- GHC.Real types and classes
 781 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
 782     integralClassName, realFracClassName, fractionalClassName,
 783     fromRationalName, toIntegerName, toRationalName, fromIntegralName,
 784     realToFracName :: Name
 785 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
 786 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
 787 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
 788 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
 789 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
 790 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
 791 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
 792 fromRationalName    = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
 793 toIntegerName       = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
 794 toRationalName      = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
 795 fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
 796 realToFracName      = varQual  gHC_REAL (fsLit "realToFrac") realToFracIdKey
 797
 798 -- PrelFloat classes
 799 floatingClassName, realFloatClassName :: Name
 800 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
 801 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
 802
 803 -- Class Ix
 804 ixClassName :: Name
 805 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
 806
 807 -- Class Typeable
 808 typeableClassName, typeable1ClassName, typeable2ClassName,
 809     typeable3ClassName, typeable4ClassName, typeable5ClassName,
 810     typeable6ClassName, typeable7ClassName :: Name
 811 typeableClassName  = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
 812 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
 813 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
 814 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
 815 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
 816 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
 817 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
 818 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
 819
 820 typeableClassNames :: [Name]
 821 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 822                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 823                         , typeable6ClassName, typeable7ClassName ]
 824
 825 -- Class Data
 826 dataClassName :: Name
 827 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
 828
 829 -- Error module
 830 assertErrorName    :: Name
 831 assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
 832
 833 -- Enum module (Enum, Bounded)
 834 enumClassName, enumFromName, enumFromToName, enumFromThenName,
 835     enumFromThenToName, boundedClassName :: Name
 836 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
 837 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
 838 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
 839 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
 840 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
 841 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
 842
 843 -- List functions
 844 concatName, filterName, zipName :: Name
 845 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
 846 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
 847 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
 848
 849 -- Class Show
 850 showClassName :: Name
 851 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
 852
 853 -- Class Read
 854 readClassName :: Name
 855 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
 856
 857 -- Classes Generic and Generic1, Datatype, Constructor and Selector
 858 genClassName, gen1ClassName, datatypeClassName, constructorClassName,
 859   selectorClassName :: Name
 860 genClassName  = clsQual gHC_GENERICS (fsLit "Generic")  genClassKey
 861 gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
 862
 863 datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
 864 constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
 865 selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
 866
 867 -- parallel array types and functions
 868 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
 869     singletonPName, replicatePName, mapPName, filterPName,
 870     zipPName, crossMapPName, indexPName, toPName,
 871     emptyPName, appPName :: PackageId -> Name
 872 enumFromToPName     pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP")     enumFromToPIdKey
 873 enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey
 874 nullPName           pkg = varQual (gHC_PARR pkg) (fsLit "nullP")           nullPIdKey
 875 lengthPName         pkg = varQual (gHC_PARR pkg) (fsLit "lengthP")         lengthPIdKey
 876 singletonPName      pkg = varQual (gHC_PARR pkg) (fsLit "singletonP")      singletonPIdKey
 877 replicatePName      pkg = varQual (gHC_PARR pkg) (fsLit "replicateP")      replicatePIdKey
 878 mapPName            pkg = varQual (gHC_PARR pkg) (fsLit "mapP")            mapPIdKey
 879 filterPName         pkg = varQual (gHC_PARR pkg) (fsLit "filterP")         filterPIdKey
 880 zipPName            pkg = varQual (gHC_PARR pkg) (fsLit "zipP")            zipPIdKey
 881 crossMapPName       pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP")       crossMapPIdKey
 882 indexPName          pkg = varQual (gHC_PARR pkg) (fsLit "!:")              indexPIdKey
 883 toPName             pkg = varQual (gHC_PARR pkg) (fsLit "toP")             toPIdKey
 884 emptyPName          pkg = varQual (gHC_PARR pkg) (fsLit "emptyP")          emptyPIdKey
 885 appPName            pkg = varQual (gHC_PARR pkg) (fsLit "+:+")             appPIdKey
 886
 887 -- IO things
 888 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
 889     failIOName :: Name
 890 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
 891 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
 892 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
 893 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
 894 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
 895 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
 896
 897 -- IO things
 898 printName :: Name
 899 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
 900
 901 -- Int, Word, and Addr things
 902 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
 903 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
 904 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
 905 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
 906 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
 907
 908 -- Word module
 909 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 910     wordTyConName, wordDataConName :: Name
 911 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
 912 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
 913 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
 914 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
 915 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
 916 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
 917
 918 -- PrelPtr module
 919 ptrTyConName, funPtrTyConName :: Name
 920 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
 921 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
 922
 923 -- Foreign objects and weak pointers
 924 stablePtrTyConName, newStablePtrName :: Name
 925 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
 926 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
 927
 928 -- PrelST module
 929 runSTRepName :: Name
 930 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
 931
 932 -- Recursive-do notation
 933 monadFixClassName, mfixName :: Name
 934 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
 935 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
 936
 937 -- Arrow notation
 938 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
 939 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
 940 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
 941 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
 942 appAName           = varQual aRROW (fsLit "app")          appAIdKey
 943 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
 944 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
 945
 946 -- Monad comprehensions
 947 guardMName, liftMName, groupMName, mzipName :: Name
 948 guardMName         = varQual mONAD (fsLit "guard") guardMIdKey
 949 liftMName          = varQual mONAD (fsLit "liftM") liftMIdKey
 950 groupMName         = varQual mONAD_GROUP (fsLit "mgroupWith") groupMIdKey
 951 mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
 952
 953
 954 -- Annotation type checking
 955 toAnnotationWrapperName :: Name
 956 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
 957
 958 -- Other classes, needed for type defaulting
 959 monadPlusClassName, randomClassName, randomGenClassName,
 960     isStringClassName :: Name
 961 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 962 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 963 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 964 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 965
 966 -- dotnet interop
 967 objectTyConName :: Name
 968 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 969         -- objectTyConName was "wTcQual", but that's gone now, and
 970         -- I can't see why it was wired in anyway...
 971 unmarshalObjectName, marshalObjectName, marshalStringName,
 972     unmarshalStringName, checkDotnetResName :: Name
 973 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 974 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 975 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 976 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 977 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 978 \end{code}
 979
 980 %************************************************************************
 981 %*                                                                      *
 982 \subsection{Local helpers}
 983 %*                                                                      *
 984 %************************************************************************
 985
 986 All these are original names; hence mkOrig
 987
 988 \begin{code}
 989 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 990 varQual  = mk_known_key_name varName
 991 tcQual   = mk_known_key_name tcName
 992 clsQual  = mk_known_key_name clsName
 993
 994 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 995 mk_known_key_name space modu str unique
 996   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 997
 998 conName :: Module -> FastString -> Unique -> Name
 999 conName modu occ unique
1000   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1001
1002 methName :: Module -> FastString -> Unique -> Name
1003 methName modu occ unique
1004   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1005 \end{code}
1006
1007 %************************************************************************
1008 %*                                                                      *
1009 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1010 %*                                                                      *
1011 %************************************************************************
1012 --MetaHaskell extension hand allocate keys here
1013
1014 \begin{code}
1015 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1016     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1017     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1018     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1019 boundedClassKey         = mkPreludeClassUnique 1
1020 enumClassKey            = mkPreludeClassUnique 2
1021 eqClassKey              = mkPreludeClassUnique 3
1022 floatingClassKey        = mkPreludeClassUnique 5
1023 fractionalClassKey      = mkPreludeClassUnique 6
1024 integralClassKey        = mkPreludeClassUnique 7
1025 monadClassKey           = mkPreludeClassUnique 8
1026 dataClassKey            = mkPreludeClassUnique 9
1027 functorClassKey         = mkPreludeClassUnique 10
1028 numClassKey             = mkPreludeClassUnique 11
1029 ordClassKey             = mkPreludeClassUnique 12
1030 readClassKey            = mkPreludeClassUnique 13
1031 realClassKey            = mkPreludeClassUnique 14
1032 realFloatClassKey       = mkPreludeClassUnique 15
1033 realFracClassKey        = mkPreludeClassUnique 16
1034 showClassKey            = mkPreludeClassUnique 17
1035 ixClassKey              = mkPreludeClassUnique 18
1036
1037 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1038     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1039     :: Unique
1040 typeableClassKey        = mkPreludeClassUnique 20
1041 typeable1ClassKey       = mkPreludeClassUnique 21
1042 typeable2ClassKey       = mkPreludeClassUnique 22
1043 typeable3ClassKey       = mkPreludeClassUnique 23
1044 typeable4ClassKey       = mkPreludeClassUnique 24
1045 typeable5ClassKey       = mkPreludeClassUnique 25
1046 typeable6ClassKey       = mkPreludeClassUnique 26
1047 typeable7ClassKey       = mkPreludeClassUnique 27
1048
1049 monadFixClassKey :: Unique
1050 monadFixClassKey        = mkPreludeClassUnique 28
1051
1052 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1053 monadPlusClassKey       = mkPreludeClassUnique 30
1054 randomClassKey          = mkPreludeClassUnique 31
1055 randomGenClassKey       = mkPreludeClassUnique 32
1056
1057 isStringClassKey :: Unique
1058 isStringClassKey        = mkPreludeClassUnique 33
1059
1060 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1061 applicativeClassKey     = mkPreludeClassUnique 34
1062 foldableClassKey        = mkPreludeClassUnique 35
1063 traversableClassKey     = mkPreludeClassUnique 36
1064
1065 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1066   selectorClassKey :: Unique
1067 genClassKey   = mkPreludeClassUnique 37
1068 gen1ClassKey  = mkPreludeClassUnique 38
1069
1070 datatypeClassKey    = mkPreludeClassUnique 39
1071 constructorClassKey = mkPreludeClassUnique 40
1072 selectorClassKey    = mkPreludeClassUnique 41
1073 \end{code}
1074
1075 %************************************************************************
1076 %*                                                                      *
1077 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1078 %*                                                                      *
1079 %************************************************************************
1080
1081 \begin{code}
1082 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1083     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1084     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1085     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1086     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1087     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1088     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1089     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1090     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1091     anyTyConKey :: Unique
1092 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1093 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1094 boolTyConKey                            = mkPreludeTyConUnique  4
1095 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1096 charPrimTyConKey                        = mkPreludeTyConUnique  7
1097 charTyConKey                            = mkPreludeTyConUnique  8
1098 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1099 doubleTyConKey                          = mkPreludeTyConUnique 10
1100 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1101 floatTyConKey                           = mkPreludeTyConUnique 12
1102 funTyConKey                             = mkPreludeTyConUnique 13
1103 intPrimTyConKey                         = mkPreludeTyConUnique 14
1104 intTyConKey                             = mkPreludeTyConUnique 15
1105 int8TyConKey                            = mkPreludeTyConUnique 16
1106 int16TyConKey                           = mkPreludeTyConUnique 17
1107 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1108 int32TyConKey                           = mkPreludeTyConUnique 19
1109 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1110 int64TyConKey                           = mkPreludeTyConUnique 21
1111 integerTyConKey                         = mkPreludeTyConUnique 22
1112 listTyConKey                            = mkPreludeTyConUnique 23
1113 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
1114 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1115 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1116 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1117 orderingTyConKey                        = mkPreludeTyConUnique 30
1118 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1119 ratioTyConKey                           = mkPreludeTyConUnique 32
1120 rationalTyConKey                        = mkPreludeTyConUnique 33
1121 realWorldTyConKey                       = mkPreludeTyConUnique 34
1122 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1123 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1124 anyTyConKey                             = mkPreludeTyConUnique 37
1125
1126 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1127     mutVarPrimTyConKey, ioTyConKey,
1128     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1129     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1130     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1131     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1132     funPtrTyConKey, tVarPrimTyConKey :: Unique
1133 statePrimTyConKey                       = mkPreludeTyConUnique 50
1134 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1135 stableNameTyConKey                      = mkPreludeTyConUnique 52
1136 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1137 ioTyConKey                              = mkPreludeTyConUnique 56
1138 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1139 wordTyConKey                            = mkPreludeTyConUnique 59
1140 word8TyConKey                           = mkPreludeTyConUnique 60
1141 word16TyConKey                          = mkPreludeTyConUnique 61
1142 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1143 word32TyConKey                          = mkPreludeTyConUnique 63
1144 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1145 word64TyConKey                          = mkPreludeTyConUnique 65
1146 liftedConKey                            = mkPreludeTyConUnique 66
1147 unliftedConKey                          = mkPreludeTyConUnique 67
1148 anyBoxConKey                            = mkPreludeTyConUnique 68
1149 kindConKey                              = mkPreludeTyConUnique 69
1150 boxityConKey                            = mkPreludeTyConUnique 70
1151 typeConKey                              = mkPreludeTyConUnique 71
1152 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1153 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1154 ptrTyConKey                             = mkPreludeTyConUnique 74
1155 funPtrTyConKey                          = mkPreludeTyConUnique 75
1156 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1157
1158 -- Parallel array type constructor
1159 parrTyConKey :: Unique
1160 parrTyConKey                            = mkPreludeTyConUnique 82
1161
1162 -- dotnet interop
1163 objectTyConKey :: Unique
1164 objectTyConKey                          = mkPreludeTyConUnique 83
1165
1166 eitherTyConKey :: Unique
1167 eitherTyConKey                          = mkPreludeTyConUnique 84
1168
1169 -- Super Kinds constructors
1170 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1171 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
1172 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
1173
1174 -- Kind constructors
1175 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1176     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1177 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1178 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1179 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1180 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1181 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1182
1183 -- Coercion constructors
1184 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1185     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1186     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1187     :: Unique
1188 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1189 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1190 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1191 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1192 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1193 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1194 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1195 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1196 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1197
1198 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1199     opaqueTyConKey :: Unique
1200 unknownTyConKey                         = mkPreludeTyConUnique 129
1201 unknown1TyConKey                        = mkPreludeTyConUnique 130
1202 unknown2TyConKey                        = mkPreludeTyConUnique 131
1203 unknown3TyConKey                        = mkPreludeTyConUnique 132
1204 opaqueTyConKey                          = mkPreludeTyConUnique 133
1205
1206 stringTyConKey :: Unique
1207 stringTyConKey                          = mkPreludeTyConUnique 134
1208
1209 -- Generics (Unique keys)
1210 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1211   k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1212   compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1213   cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1214   d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1215   repTyConKey, rep1TyConKey :: Unique
1216
1217 v1TyConKey    = mkPreludeTyConUnique 135
1218 u1TyConKey    = mkPreludeTyConUnique 136
1219 par1TyConKey  = mkPreludeTyConUnique 137
1220 rec1TyConKey  = mkPreludeTyConUnique 138
1221 k1TyConKey    = mkPreludeTyConUnique 139
1222 m1TyConKey    = mkPreludeTyConUnique 140
1223
1224 sumTyConKey   = mkPreludeTyConUnique 141
1225 prodTyConKey  = mkPreludeTyConUnique 142
1226 compTyConKey  = mkPreludeTyConUnique 143
1227
1228 rTyConKey = mkPreludeTyConUnique 144
1229 pTyConKey = mkPreludeTyConUnique 145
1230 dTyConKey = mkPreludeTyConUnique 146
1231 cTyConKey = mkPreludeTyConUnique 147
1232 sTyConKey = mkPreludeTyConUnique 148
1233
1234 rec0TyConKey  = mkPreludeTyConUnique 149
1235 par0TyConKey  = mkPreludeTyConUnique 150
1236 d1TyConKey    = mkPreludeTyConUnique 151
1237 c1TyConKey    = mkPreludeTyConUnique 152
1238 s1TyConKey    = mkPreludeTyConUnique 153
1239 noSelTyConKey = mkPreludeTyConUnique 154
1240
1241 repTyConKey  = mkPreludeTyConUnique 155
1242 rep1TyConKey = mkPreludeTyConUnique 156
1243
1244 ---------------- Template Haskell -------------------
1245 --      USES TyConUniques 200-299
1246 -----------------------------------------------------
1247
1248 unitTyConKey :: Unique
1249 unitTyConKey = mkTupleTyConUnique Boxed 0
1250 \end{code}
1251
1252 %************************************************************************
1253 %*                                                                      *
1254 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1255 %*                                                                      *
1256 %************************************************************************
1257
1258 \begin{code}
1259 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1260     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1261     stableNameDataConKey, trueDataConKey, wordDataConKey,
1262     ioDataConKey, integerDataConKey :: Unique
1263 charDataConKey                          = mkPreludeDataConUnique  1
1264 consDataConKey                          = mkPreludeDataConUnique  2
1265 doubleDataConKey                        = mkPreludeDataConUnique  3
1266 falseDataConKey                         = mkPreludeDataConUnique  4
1267 floatDataConKey                         = mkPreludeDataConUnique  5
1268 intDataConKey                           = mkPreludeDataConUnique  6
1269 nilDataConKey                           = mkPreludeDataConUnique 11
1270 ratioDataConKey                         = mkPreludeDataConUnique 12
1271 stableNameDataConKey                    = mkPreludeDataConUnique 14
1272 trueDataConKey                          = mkPreludeDataConUnique 15
1273 wordDataConKey                          = mkPreludeDataConUnique 16
1274 ioDataConKey                            = mkPreludeDataConUnique 17
1275 integerDataConKey                       = mkPreludeDataConUnique 18
1276
1277 -- Generic data constructors
1278 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1279 crossDataConKey                         = mkPreludeDataConUnique 20
1280 inlDataConKey                           = mkPreludeDataConUnique 21
1281 inrDataConKey                           = mkPreludeDataConUnique 22
1282 genUnitDataConKey                       = mkPreludeDataConUnique 23
1283
1284 -- Data constructor for parallel arrays
1285 parrDataConKey :: Unique
1286 parrDataConKey                          = mkPreludeDataConUnique 24
1287
1288 leftDataConKey, rightDataConKey :: Unique
1289 leftDataConKey                          = mkPreludeDataConUnique 25
1290 rightDataConKey                         = mkPreludeDataConUnique 26
1291 \end{code}
1292
1293 %************************************************************************
1294 %*                                                                      *
1295 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1296 %*                                                                      *
1297 %************************************************************************
1298
1299 \begin{code}
1300 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1301     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1302     integerMinusOneIdKey, integerPlusOneIdKey,
1303     integerPlusTwoIdKey, integerZeroIdKey,
1304     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1305     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1306     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1307     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1308     traceIdKey, wildCardKey,
1309     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1310     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1311 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1312 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1313 augmentIdKey                  = mkPreludeMiscIdUnique  3
1314 appendIdKey                   = mkPreludeMiscIdUnique  4
1315 buildIdKey                    = mkPreludeMiscIdUnique  5
1316 errorIdKey                    = mkPreludeMiscIdUnique  6
1317 foldlIdKey                    = mkPreludeMiscIdUnique  7
1318 foldrIdKey                    = mkPreludeMiscIdUnique  8
1319 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1320 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1321 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1322 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1323 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1324 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1325 seqIdKey                      = mkPreludeMiscIdUnique 15
1326 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1327 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1328 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1329 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1330 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1331 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1332 parIdKey                      = mkPreludeMiscIdUnique 22
1333 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1334 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1335 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1336 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1337 traceIdKey                    = mkPreludeMiscIdUnique 27
1338 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1339 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1340 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1341 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1342
1343 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1344     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1345     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1346     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1347     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1348 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1349 concatIdKey                   = mkPreludeMiscIdUnique 33
1350 filterIdKey                   = mkPreludeMiscIdUnique 34
1351 zipIdKey                      = mkPreludeMiscIdUnique 35
1352 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1353 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1354 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1355 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1356 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1357 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1358 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1359 printIdKey                    = mkPreludeMiscIdUnique 43
1360 failIOIdKey                   = mkPreludeMiscIdUnique 44
1361 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1362 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1363 fstIdKey                      = mkPreludeMiscIdUnique 49
1364 sndIdKey                      = mkPreludeMiscIdUnique 50
1365 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1366 assertIdKey                   = mkPreludeMiscIdUnique 53
1367 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1368
1369 rootMainKey, runMainKey :: Unique
1370 rootMainKey                   = mkPreludeMiscIdUnique 55
1371 runMainKey                    = mkPreludeMiscIdUnique 56
1372
1373 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1374 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1375 lazyIdKey                     = mkPreludeMiscIdUnique 60
1376 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1377
1378 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1379     breakpointJumpIdKey, breakpointCondJumpIdKey,
1380     breakpointAutoJumpIdKey :: Unique
1381 breakpointIdKey               = mkPreludeMiscIdUnique 62
1382 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1383 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1384 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1385 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1386 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1387
1388 inlineIdKey :: Unique
1389 inlineIdKey                   = mkPreludeMiscIdUnique 68
1390
1391 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1392 mapIdKey              = mkPreludeMiscIdUnique 69
1393 groupWithIdKey        = mkPreludeMiscIdUnique 70
1394 dollarIdKey           = mkPreludeMiscIdUnique 71
1395
1396 -- Parallel array functions
1397 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1398     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1399     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1400 singletonPIdKey               = mkPreludeMiscIdUnique 79
1401 nullPIdKey                    = mkPreludeMiscIdUnique 80
1402 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1403 replicatePIdKey               = mkPreludeMiscIdUnique 82
1404 mapPIdKey                     = mkPreludeMiscIdUnique 83
1405 filterPIdKey                  = mkPreludeMiscIdUnique 84
1406 zipPIdKey                     = mkPreludeMiscIdUnique 85
1407 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1408 indexPIdKey                   = mkPreludeMiscIdUnique 87
1409 toPIdKey                      = mkPreludeMiscIdUnique 88
1410 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1411 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1412 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1413 appPIdKey                     = mkPreludeMiscIdUnique 92
1414
1415 -- dotnet interop
1416 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1417     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1418 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1419 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1420 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1421 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1422 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1423
1424 \end{code}
1425
1426 Certain class operations from Prelude classes.  They get their own
1427 uniques so we can look them up easily when we want to conjure them up
1428 during type checking.
1429
1430 \begin{code}
1431         -- Just a place holder for  unbound variables  produced by the renamer:
1432 unboundKey :: Unique
1433 unboundKey                    = mkPreludeMiscIdUnique 101
1434
1435 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1436     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1437     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1438     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1439     fmapClassOpKey
1440     :: Unique
1441 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1442 minusClassOpKey               = mkPreludeMiscIdUnique 103
1443 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1444 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1445 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1446 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1447 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1448 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1449 geClassOpKey                  = mkPreludeMiscIdUnique 110
1450 negateClassOpKey              = mkPreludeMiscIdUnique 111
1451 failMClassOpKey               = mkPreludeMiscIdUnique 112
1452 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1453 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1454 fmapClassOpKey                = mkPreludeMiscIdUnique 115
1455 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1456
1457 -- Recursive do notation
1458 mfixIdKey :: Unique
1459 mfixIdKey       = mkPreludeMiscIdUnique 118
1460
1461 -- Arrow notation
1462 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1463     loopAIdKey :: Unique
1464 arrAIdKey       = mkPreludeMiscIdUnique 119
1465 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1466 firstAIdKey     = mkPreludeMiscIdUnique 121
1467 appAIdKey       = mkPreludeMiscIdUnique 122
1468 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1469 loopAIdKey      = mkPreludeMiscIdUnique 124
1470
1471 fromStringClassOpKey :: Unique
1472 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1473
1474 -- Annotation type checking
1475 toAnnotationWrapperIdKey :: Unique
1476 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 126
1477
1478 -- Conversion functions
1479 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1480 fromIntegralIdKey    = mkPreludeMiscIdUnique 127
1481 realToFracIdKey      = mkPreludeMiscIdUnique 128
1482 toIntegerClassOpKey  = mkPreludeMiscIdUnique 129
1483 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1484
1485 -- Monad comprehensions
1486 guardMIdKey, liftMIdKey, groupMIdKey, mzipIdKey :: Unique
1487 guardMIdKey     = mkPreludeMiscIdUnique 131
1488 liftMIdKey      = mkPreludeMiscIdUnique 132
1489 groupMIdKey     = mkPreludeMiscIdUnique 133
1490 mzipIdKey       = mkPreludeMiscIdUnique 134
1491
1492
1493 ---------------- Template Haskell -------------------
1494 --      USES IdUniques 200-499
1495 -----------------------------------------------------
1496 \end{code}
1497
1498
1499 %************************************************************************
1500 %*                                                                      *
1501 \subsection{Standard groups of types}
1502 %*                                                                      *
1503 %************************************************************************
1504
1505 \begin{code}
1506 numericTyKeys :: [Unique]
1507 numericTyKeys =
1508         [ wordTyConKey
1509         , intTyConKey
1510         , integerTyConKey
1511         , doubleTyConKey
1512         , floatTyConKey
1513         ]
1514
1515 kindKeys :: [Unique]
1516 kindKeys = [ liftedTypeKindTyConKey
1517            , openTypeKindTyConKey
1518            , unliftedTypeKindTyConKey
1519            , ubxTupleKindTyConKey
1520            , argTypeKindTyConKey ]
1521 \end{code}
1522
1523
1524 %************************************************************************
1525 %*                                                                      *
1526 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1527 %*                                                                      *
1528 %************************************************************************
1529
1530 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1531 even though every numeric class has these two as a superclass,
1532 because the list of ambiguous dictionaries hasn't been simplified.
1533
1534 \begin{code}
1535 numericClassKeys :: [Unique]
1536 numericClassKeys =
1537         [ numClassKey
1538         , realClassKey
1539         , integralClassKey
1540         ]
1541         ++ fractionalClassKeys
1542
1543 fractionalClassKeys :: [Unique]
1544 fractionalClassKeys =
1545         [ fractionalClassKey
1546         , floatingClassKey
1547         , realFracClassKey
1548         , realFloatClassKey
1549         ]
1550
1551         -- the strictness analyser needs to know about numeric types
1552         -- (see SaAbsInt.lhs)
1553 needsDataDeclCtxtClassKeys :: [Unique]
1554 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1555         [ readClassKey
1556         ]
1557
1558 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1559 -- and are: "classes defined in the Prelude or a standard library"
1560 standardClassKeys :: [Unique]
1561 standardClassKeys = derivableClassKeys ++ numericClassKeys
1562                   ++ [randomClassKey, randomGenClassKey,
1563                       functorClassKey,
1564                       monadClassKey, monadPlusClassKey,
1565                       isStringClassKey,
1566                       applicativeClassKey, foldableClassKey, traversableClassKey
1567                      ]
1568 \end{code}
1569
1570 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1571 (@TcDeriv@).
1572
1573 \begin{code}
1574 derivableClassKeys :: [Unique]
1575 derivableClassKeys
1576   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1577       boundedClassKey, showClassKey, readClassKey ]
1578 \end{code}
1579