compiler/prelude/PrelNames.lhs

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