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