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