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, conIsTuple_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 conIsTuple_RDR    = varQual_RDR gHC_GENERICS (fsLit "conIsTuple")
 588
 589 noArityDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
 590 arityDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Arity")
 591 prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
 592 infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")
 593 leftAssocDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
 594 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
 595 notAssocDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
 596
 597
 598 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
 599 fmap_RDR                = varQual_RDR gHC_BASE (fsLit "fmap")
 600 pure_RDR                = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
 601 ap_RDR                  = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
 602 foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")
 603 traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")
 604
 605 ----------------------
 606 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
 607     :: Module -> FastString -> RdrName
 608 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
 609 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
 610 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
 611 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
 612 \end{code}
 613
 614 %************************************************************************
 615 %*                                                                      *
 616 \subsection{Known-key names}
 617 %*                                                                      *
 618 %************************************************************************
 619
 620 Many of these Names are not really "built in", but some parts of the
 621 compiler (notably the deriving mechanism) need to mention their names,
 622 and it's convenient to write them all down in one place.
 623
 624 --MetaHaskell Extension  add the constrs and the lower case case
 625 -- guys as well (perhaps) e.g. see  trueDataConName     below
 626
 627
 628 \begin{code}
 629 wildCardName :: Name
 630 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
 631
 632 runMainIOName :: Name
 633 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
 634
 635 orderingTyConName :: Name
 636 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
 637
 638 eitherTyConName, leftDataConName, rightDataConName :: Name
 639 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
 640 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
 641 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
 642
 643 -- Old Generics (types)
 644 crossTyConName, plusTyConName, genUnitTyConName :: Name
 645 crossTyConName     = tcQual   gHC_GENERICS (fsLit ":*:") crossTyConKey
 646 plusTyConName      = tcQual   gHC_GENERICS (fsLit ":+:") plusTyConKey
 647 genUnitTyConName   = tcQual   gHC_GENERICS (fsLit "Unit") genUnitTyConKey
 648
 649 -- Generics (types)
 650 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
 651   k1TyConName, m1TyConName, sumTyConName, prodTyConName,
 652   compTyConName, rTyConName, pTyConName, dTyConName,
 653   cTyConName, sTyConName, rec0TyConName, par0TyConName,
 654   d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
 655   rep0TyConName, rep1TyConName :: Name
 656
 657 v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
 658 u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
 659 par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
 660 rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
 661 k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
 662 m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
 663
 664 sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
 665 prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
 666 compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
 667
 668 rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey
 669 pTyConName  = tcQual gHC_GENERICS (fsLit "P") pTyConKey
 670 dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey
 671 cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey
 672 sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey
 673
 674 rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
 675 par0TyConName  = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
 676 d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
 677 c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
 678 s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
 679 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
 680
 681 rep0TyConName = tcQual gHC_GENERICS (fsLit "Rep0") rep0TyConKey
 682 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
 683
 684 -- Base strings Strings
 685 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
 686     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
 687 unpackCStringName       = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
 688 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
 689 unpackCStringFoldrName  = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
 690 unpackCStringUtf8Name   = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
 691 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
 692 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
 693
 694 -- The 'inline' function
 695 inlineIdName :: Name
 696 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
 697
 698 -- Base classes (Eq, Ord, Functor)
 699 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
 700 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
 701 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
 702 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
 703 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
 704 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
 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 Representable0 and Representable1, Datatype, Constructor and Selector
 858 rep0ClassName, rep1ClassName, datatypeClassName, constructorClassName,
 859   selectorClassName :: Name
 860 rep0ClassName = clsQual gHC_GENERICS (fsLit "Representable0") rep0ClassKey
 861 rep1ClassName = clsQual gHC_GENERICS (fsLit "Representable1") rep1ClassKey
 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 -- Annotation type checking
 947 toAnnotationWrapperName :: Name
 948 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
 949
 950 -- Other classes, needed for type defaulting
 951 monadPlusClassName, randomClassName, randomGenClassName,
 952     isStringClassName :: Name
 953 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 954 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 955 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 956 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 957
 958 -- dotnet interop
 959 objectTyConName :: Name
 960 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 961         -- objectTyConName was "wTcQual", but that's gone now, and
 962         -- I can't see why it was wired in anyway...
 963 unmarshalObjectName, marshalObjectName, marshalStringName,
 964     unmarshalStringName, checkDotnetResName :: Name
 965 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 966 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 967 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 968 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 969 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 970 \end{code}
 971
 972 %************************************************************************
 973 %*                                                                      *
 974 \subsection{Local helpers}
 975 %*                                                                      *
 976 %************************************************************************
 977
 978 All these are original names; hence mkOrig
 979
 980 \begin{code}
 981 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 982 varQual  = mk_known_key_name varName
 983 tcQual   = mk_known_key_name tcName
 984 clsQual  = mk_known_key_name clsName
 985
 986 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 987 mk_known_key_name space modu str unique
 988   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 989
 990 conName :: Module -> FastString -> Unique -> Name
 991 conName modu occ unique
 992   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
 993
 994 methName :: Module -> FastString -> Unique -> Name
 995 methName modu occ unique
 996   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
 997 \end{code}
 998
 999 %************************************************************************
1000 %*                                                                      *
1001 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1002 %*                                                                      *
1003 %************************************************************************
1004 --MetaHaskell extension hand allocate keys here
1005
1006 \begin{code}
1007 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1008     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1009     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1010     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1011 boundedClassKey         = mkPreludeClassUnique 1
1012 enumClassKey            = mkPreludeClassUnique 2
1013 eqClassKey              = mkPreludeClassUnique 3
1014 floatingClassKey        = mkPreludeClassUnique 5
1015 fractionalClassKey      = mkPreludeClassUnique 6
1016 integralClassKey        = mkPreludeClassUnique 7
1017 monadClassKey           = mkPreludeClassUnique 8
1018 dataClassKey            = mkPreludeClassUnique 9
1019 functorClassKey         = mkPreludeClassUnique 10
1020 numClassKey             = mkPreludeClassUnique 11
1021 ordClassKey             = mkPreludeClassUnique 12
1022 readClassKey            = mkPreludeClassUnique 13
1023 realClassKey            = mkPreludeClassUnique 14
1024 realFloatClassKey       = mkPreludeClassUnique 15
1025 realFracClassKey        = mkPreludeClassUnique 16
1026 showClassKey            = mkPreludeClassUnique 17
1027 ixClassKey              = mkPreludeClassUnique 18
1028
1029 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1030     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1031     :: Unique
1032 typeableClassKey        = mkPreludeClassUnique 20
1033 typeable1ClassKey       = mkPreludeClassUnique 21
1034 typeable2ClassKey       = mkPreludeClassUnique 22
1035 typeable3ClassKey       = mkPreludeClassUnique 23
1036 typeable4ClassKey       = mkPreludeClassUnique 24
1037 typeable5ClassKey       = mkPreludeClassUnique 25
1038 typeable6ClassKey       = mkPreludeClassUnique 26
1039 typeable7ClassKey       = mkPreludeClassUnique 27
1040
1041 monadFixClassKey :: Unique
1042 monadFixClassKey        = mkPreludeClassUnique 28
1043
1044 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1045 monadPlusClassKey       = mkPreludeClassUnique 30
1046 randomClassKey          = mkPreludeClassUnique 31
1047 randomGenClassKey       = mkPreludeClassUnique 32
1048
1049 isStringClassKey :: Unique
1050 isStringClassKey        = mkPreludeClassUnique 33
1051
1052 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1053 applicativeClassKey     = mkPreludeClassUnique 34
1054 foldableClassKey        = mkPreludeClassUnique 35
1055 traversableClassKey     = mkPreludeClassUnique 36
1056
1057 rep0ClassKey, rep1ClassKey, datatypeClassKey, constructorClassKey,
1058   selectorClassKey :: Unique
1059 rep0ClassKey  = mkPreludeClassUnique 37
1060 rep1ClassKey  = mkPreludeClassUnique 38
1061
1062 datatypeClassKey    = mkPreludeClassUnique 39
1063 constructorClassKey = mkPreludeClassUnique 40
1064 selectorClassKey    = mkPreludeClassUnique 41
1065 \end{code}
1066
1067 %************************************************************************
1068 %*                                                                      *
1069 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1070 %*                                                                      *
1071 %************************************************************************
1072
1073 \begin{code}
1074 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1075     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1076     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1077     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1078     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1079     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1080     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1081     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1082     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1083     anyTyConKey :: Unique
1084 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1085 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1086 boolTyConKey                            = mkPreludeTyConUnique  4
1087 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1088 charPrimTyConKey                        = mkPreludeTyConUnique  7
1089 charTyConKey                            = mkPreludeTyConUnique  8
1090 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1091 doubleTyConKey                          = mkPreludeTyConUnique 10
1092 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1093 floatTyConKey                           = mkPreludeTyConUnique 12
1094 funTyConKey                             = mkPreludeTyConUnique 13
1095 intPrimTyConKey                         = mkPreludeTyConUnique 14
1096 intTyConKey                             = mkPreludeTyConUnique 15
1097 int8TyConKey                            = mkPreludeTyConUnique 16
1098 int16TyConKey                           = mkPreludeTyConUnique 17
1099 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1100 int32TyConKey                           = mkPreludeTyConUnique 19
1101 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1102 int64TyConKey                           = mkPreludeTyConUnique 21
1103 integerTyConKey                         = mkPreludeTyConUnique 22
1104 listTyConKey                            = mkPreludeTyConUnique 23
1105 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
1106 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1107 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1108 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1109 orderingTyConKey                        = mkPreludeTyConUnique 30
1110 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1111 ratioTyConKey                           = mkPreludeTyConUnique 32
1112 rationalTyConKey                        = mkPreludeTyConUnique 33
1113 realWorldTyConKey                       = mkPreludeTyConUnique 34
1114 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1115 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1116 anyTyConKey                             = mkPreludeTyConUnique 37
1117
1118 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1119     mutVarPrimTyConKey, ioTyConKey,
1120     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1121     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1122     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1123     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1124     funPtrTyConKey, tVarPrimTyConKey :: Unique
1125 statePrimTyConKey                       = mkPreludeTyConUnique 50
1126 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1127 stableNameTyConKey                      = mkPreludeTyConUnique 52
1128 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1129 ioTyConKey                              = mkPreludeTyConUnique 56
1130 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1131 wordTyConKey                            = mkPreludeTyConUnique 59
1132 word8TyConKey                           = mkPreludeTyConUnique 60
1133 word16TyConKey                          = mkPreludeTyConUnique 61
1134 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1135 word32TyConKey                          = mkPreludeTyConUnique 63
1136 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1137 word64TyConKey                          = mkPreludeTyConUnique 65
1138 liftedConKey                            = mkPreludeTyConUnique 66
1139 unliftedConKey                          = mkPreludeTyConUnique 67
1140 anyBoxConKey                            = mkPreludeTyConUnique 68
1141 kindConKey                              = mkPreludeTyConUnique 69
1142 boxityConKey                            = mkPreludeTyConUnique 70
1143 typeConKey                              = mkPreludeTyConUnique 71
1144 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1145 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1146 ptrTyConKey                             = mkPreludeTyConUnique 74
1147 funPtrTyConKey                          = mkPreludeTyConUnique 75
1148 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1149
1150 -- Old Generic Type Constructors
1151 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1152 crossTyConKey                           = mkPreludeTyConUnique 79
1153 plusTyConKey                            = mkPreludeTyConUnique 80
1154 genUnitTyConKey                         = mkPreludeTyConUnique 81
1155
1156 -- Parallel array type constructor
1157 parrTyConKey :: Unique
1158 parrTyConKey                            = mkPreludeTyConUnique 82
1159
1160 -- dotnet interop
1161 objectTyConKey :: Unique
1162 objectTyConKey                          = mkPreludeTyConUnique 83
1163
1164 eitherTyConKey :: Unique
1165 eitherTyConKey                          = mkPreludeTyConUnique 84
1166
1167 -- Super Kinds constructors
1168 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1169 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
1170 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
1171
1172 -- Kind constructors
1173 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1174     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1175 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1176 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1177 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1178 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1179 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1180
1181 -- Coercion constructors
1182 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1183     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1184     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1185     :: Unique
1186 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1187 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1188 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1189 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1190 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1191 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1192 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1193 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1194 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1195
1196 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1197     opaqueTyConKey :: Unique
1198 unknownTyConKey                         = mkPreludeTyConUnique 129
1199 unknown1TyConKey                        = mkPreludeTyConUnique 130
1200 unknown2TyConKey                        = mkPreludeTyConUnique 131
1201 unknown3TyConKey                        = mkPreludeTyConUnique 132
1202 opaqueTyConKey                          = mkPreludeTyConUnique 133
1203
1204 stringTyConKey :: Unique
1205 stringTyConKey                          = mkPreludeTyConUnique 134
1206
1207 -- Generics (Unique keys)
1208 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1209   k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1210   compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1211   cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1212   d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1213   rep0TyConKey, rep1TyConKey :: Unique
1214
1215 v1TyConKey    = mkPreludeTyConUnique 135
1216 u1TyConKey    = mkPreludeTyConUnique 136
1217 par1TyConKey  = mkPreludeTyConUnique 137
1218 rec1TyConKey  = mkPreludeTyConUnique 138
1219 k1TyConKey    = mkPreludeTyConUnique 139
1220 m1TyConKey    = mkPreludeTyConUnique 140
1221
1222 sumTyConKey   = mkPreludeTyConUnique 141
1223 prodTyConKey  = mkPreludeTyConUnique 142
1224 compTyConKey  = mkPreludeTyConUnique 143
1225
1226 rTyConKey = mkPreludeTyConUnique 144
1227 pTyConKey = mkPreludeTyConUnique 145
1228 dTyConKey = mkPreludeTyConUnique 146
1229 cTyConKey = mkPreludeTyConUnique 147
1230 sTyConKey = mkPreludeTyConUnique 148
1231
1232 rec0TyConKey  = mkPreludeTyConUnique 149
1233 par0TyConKey  = mkPreludeTyConUnique 150
1234 d1TyConKey    = mkPreludeTyConUnique 151
1235 c1TyConKey    = mkPreludeTyConUnique 152
1236 s1TyConKey    = mkPreludeTyConUnique 153
1237 noSelTyConKey = mkPreludeTyConUnique 154
1238
1239 rep0TyConKey = mkPreludeTyConUnique 155
1240 rep1TyConKey = mkPreludeTyConUnique 156
1241
1242 ---------------- Template Haskell -------------------
1243 --      USES TyConUniques 200-299
1244 -----------------------------------------------------
1245
1246 unitTyConKey :: Unique
1247 unitTyConKey = mkTupleTyConUnique Boxed 0
1248 \end{code}
1249
1250 %************************************************************************
1251 %*                                                                      *
1252 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1253 %*                                                                      *
1254 %************************************************************************
1255
1256 \begin{code}
1257 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1258     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1259     stableNameDataConKey, trueDataConKey, wordDataConKey,
1260     ioDataConKey, integerDataConKey :: Unique
1261 charDataConKey                          = mkPreludeDataConUnique  1
1262 consDataConKey                          = mkPreludeDataConUnique  2
1263 doubleDataConKey                        = mkPreludeDataConUnique  3
1264 falseDataConKey                         = mkPreludeDataConUnique  4
1265 floatDataConKey                         = mkPreludeDataConUnique  5
1266 intDataConKey                           = mkPreludeDataConUnique  6
1267 nilDataConKey                           = mkPreludeDataConUnique 11
1268 ratioDataConKey                         = mkPreludeDataConUnique 12
1269 stableNameDataConKey                    = mkPreludeDataConUnique 14
1270 trueDataConKey                          = mkPreludeDataConUnique 15
1271 wordDataConKey                          = mkPreludeDataConUnique 16
1272 ioDataConKey                            = mkPreludeDataConUnique 17
1273 integerDataConKey                       = mkPreludeDataConUnique 18
1274
1275 -- Generic data constructors
1276 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1277 crossDataConKey                         = mkPreludeDataConUnique 20
1278 inlDataConKey                           = mkPreludeDataConUnique 21
1279 inrDataConKey                           = mkPreludeDataConUnique 22
1280 genUnitDataConKey                       = mkPreludeDataConUnique 23
1281
1282 -- Data constructor for parallel arrays
1283 parrDataConKey :: Unique
1284 parrDataConKey                          = mkPreludeDataConUnique 24
1285
1286 leftDataConKey, rightDataConKey :: Unique
1287 leftDataConKey                          = mkPreludeDataConUnique 25
1288 rightDataConKey                         = mkPreludeDataConUnique 26
1289 \end{code}
1290
1291 %************************************************************************
1292 %*                                                                      *
1293 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1294 %*                                                                      *
1295 %************************************************************************
1296
1297 \begin{code}
1298 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1299     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1300     integerMinusOneIdKey, integerPlusOneIdKey,
1301     integerPlusTwoIdKey, integerZeroIdKey,
1302     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1303     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1304     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1305     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1306     traceIdKey, wildCardKey,
1307     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1308     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1309 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1310 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1311 augmentIdKey                  = mkPreludeMiscIdUnique  3
1312 appendIdKey                   = mkPreludeMiscIdUnique  4
1313 buildIdKey                    = mkPreludeMiscIdUnique  5
1314 errorIdKey                    = mkPreludeMiscIdUnique  6
1315 foldlIdKey                    = mkPreludeMiscIdUnique  7
1316 foldrIdKey                    = mkPreludeMiscIdUnique  8
1317 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1318 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1319 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1320 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1321 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1322 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1323 seqIdKey                      = mkPreludeMiscIdUnique 15
1324 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1325 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1326 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1327 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1328 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1329 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1330 parIdKey                      = mkPreludeMiscIdUnique 22
1331 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1332 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1333 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1334 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1335 traceIdKey                    = mkPreludeMiscIdUnique 27
1336 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1337 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1338 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1339 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1340
1341 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1342     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1343     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1344     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1345     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1346 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1347 concatIdKey                   = mkPreludeMiscIdUnique 33
1348 filterIdKey                   = mkPreludeMiscIdUnique 34
1349 zipIdKey                      = mkPreludeMiscIdUnique 35
1350 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1351 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1352 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1353 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1354 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1355 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1356 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1357 printIdKey                    = mkPreludeMiscIdUnique 43
1358 failIOIdKey                   = mkPreludeMiscIdUnique 44
1359 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1360 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1361 fstIdKey                      = mkPreludeMiscIdUnique 49
1362 sndIdKey                      = mkPreludeMiscIdUnique 50
1363 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1364 assertIdKey                   = mkPreludeMiscIdUnique 53
1365 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1366
1367 rootMainKey, runMainKey :: Unique
1368 rootMainKey                   = mkPreludeMiscIdUnique 55
1369 runMainKey                    = mkPreludeMiscIdUnique 56
1370
1371 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1372 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1373 lazyIdKey                     = mkPreludeMiscIdUnique 60
1374 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1375
1376 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1377     breakpointJumpIdKey, breakpointCondJumpIdKey,
1378     breakpointAutoJumpIdKey :: Unique
1379 breakpointIdKey               = mkPreludeMiscIdUnique 62
1380 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1381 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1382 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1383 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1384 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1385
1386 inlineIdKey :: Unique
1387 inlineIdKey                   = mkPreludeMiscIdUnique 68
1388
1389 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1390 mapIdKey              = mkPreludeMiscIdUnique 69
1391 groupWithIdKey        = mkPreludeMiscIdUnique 70
1392 dollarIdKey           = mkPreludeMiscIdUnique 71
1393
1394 -- Parallel array functions
1395 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1396     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1397     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1398 singletonPIdKey               = mkPreludeMiscIdUnique 79
1399 nullPIdKey                    = mkPreludeMiscIdUnique 80
1400 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1401 replicatePIdKey               = mkPreludeMiscIdUnique 82
1402 mapPIdKey                     = mkPreludeMiscIdUnique 83
1403 filterPIdKey                  = mkPreludeMiscIdUnique 84
1404 zipPIdKey                     = mkPreludeMiscIdUnique 85
1405 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1406 indexPIdKey                   = mkPreludeMiscIdUnique 87
1407 toPIdKey                      = mkPreludeMiscIdUnique 88
1408 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1409 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1410 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1411 appPIdKey                     = mkPreludeMiscIdUnique 92
1412
1413 -- dotnet interop
1414 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1415     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1416 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1417 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1418 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1419 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1420 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1421
1422 \end{code}
1423
1424 Certain class operations from Prelude classes.  They get their own
1425 uniques so we can look them up easily when we want to conjure them up
1426 during type checking.
1427
1428 \begin{code}
1429         -- Just a place holder for  unbound variables  produced by the renamer:
1430 unboundKey :: Unique
1431 unboundKey                    = mkPreludeMiscIdUnique 101
1432
1433 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1434     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1435     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1436     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1437     :: Unique
1438 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1439 minusClassOpKey               = mkPreludeMiscIdUnique 103
1440 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1441 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1442 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1443 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1444 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1445 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1446 geClassOpKey                  = mkPreludeMiscIdUnique 110
1447 negateClassOpKey              = mkPreludeMiscIdUnique 111
1448 failMClassOpKey               = mkPreludeMiscIdUnique 112
1449 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1450 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1451 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1452
1453 -- Recursive do notation
1454 mfixIdKey :: Unique
1455 mfixIdKey       = mkPreludeMiscIdUnique 118
1456
1457 -- Arrow notation
1458 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1459     loopAIdKey :: Unique
1460 arrAIdKey       = mkPreludeMiscIdUnique 119
1461 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1462 firstAIdKey     = mkPreludeMiscIdUnique 121
1463 appAIdKey       = mkPreludeMiscIdUnique 122
1464 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1465 loopAIdKey      = mkPreludeMiscIdUnique 124
1466
1467 fromStringClassOpKey :: Unique
1468 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1469
1470 -- Annotation type checking
1471 toAnnotationWrapperIdKey :: Unique
1472 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 126
1473
1474 -- Conversion functions
1475 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1476 fromIntegralIdKey    = mkPreludeMiscIdUnique 127
1477 realToFracIdKey      = mkPreludeMiscIdUnique 128
1478 toIntegerClassOpKey  = mkPreludeMiscIdUnique 129
1479 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1480
1481 ---------------- Template Haskell -------------------
1482 --      USES IdUniques 200-499
1483 -----------------------------------------------------
1484 \end{code}
1485
1486
1487 %************************************************************************
1488 %*                                                                      *
1489 \subsection{Standard groups of types}
1490 %*                                                                      *
1491 %************************************************************************
1492
1493 \begin{code}
1494 numericTyKeys :: [Unique]
1495 numericTyKeys =
1496         [ wordTyConKey
1497         , intTyConKey
1498         , integerTyConKey
1499         , doubleTyConKey
1500         , floatTyConKey
1501         ]
1502
1503 kindKeys :: [Unique]
1504 kindKeys = [ liftedTypeKindTyConKey
1505            , openTypeKindTyConKey
1506            , unliftedTypeKindTyConKey
1507            , ubxTupleKindTyConKey
1508            , argTypeKindTyConKey ]
1509 \end{code}
1510
1511
1512 %************************************************************************
1513 %*                                                                      *
1514 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1515 %*                                                                      *
1516 %************************************************************************
1517
1518 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1519 even though every numeric class has these two as a superclass,
1520 because the list of ambiguous dictionaries hasn't been simplified.
1521
1522 \begin{code}
1523 numericClassKeys :: [Unique]
1524 numericClassKeys =
1525         [ numClassKey
1526         , realClassKey
1527         , integralClassKey
1528         ]
1529         ++ fractionalClassKeys
1530
1531 fractionalClassKeys :: [Unique]
1532 fractionalClassKeys =
1533         [ fractionalClassKey
1534         , floatingClassKey
1535         , realFracClassKey
1536         , realFloatClassKey
1537         ]
1538
1539         -- the strictness analyser needs to know about numeric types
1540         -- (see SaAbsInt.lhs)
1541 needsDataDeclCtxtClassKeys :: [Unique]
1542 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1543         [ readClassKey
1544         ]
1545
1546 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1547 -- and are: "classes defined in the Prelude or a standard library"
1548 standardClassKeys :: [Unique]
1549 standardClassKeys = derivableClassKeys ++ numericClassKeys
1550                   ++ [randomClassKey, randomGenClassKey,
1551                       functorClassKey,
1552                       monadClassKey, monadPlusClassKey,
1553                       isStringClassKey,
1554                       applicativeClassKey, foldableClassKey, traversableClassKey
1555                      ]
1556 \end{code}
1557
1558 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1559 (@TcDeriv@).
1560
1561 \begin{code}
1562 derivableClassKeys :: [Unique]
1563 derivableClassKeys
1564   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1565       boundedClassKey, showClassKey, readClassKey ]
1566 \end{code}
1567