compiler/prelude/PrelNames.lhs

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