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