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