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