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