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, hetmet_flatten_name, hetmet_unflatten_name, hetmet_flattened_id_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, hetmet_flatten_name, hetmet_unflatten_name, hetmet_flattened_id_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_flatten_name  = varQual gHC_HETMET_CODETYPES (fsLit "pga_flatten") hetmet_flatten_key
 812 hetmet_unflatten_name  = varQual gHC_HETMET_CODETYPES (fsLit "pga_unflatten") hetmet_unflatten_key
 813 hetmet_flattened_id_name  = varQual gHC_HETMET_CODETYPES (fsLit "pga_flattened_id") hetmet_flattened_id_key
 814 hetmet_guest_integer_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestIntegerLiteral") hetmet_guest_integer_literal_key
 815 hetmet_guest_string_literal_name  = varQual gHC_HETMET_CODETYPES (fsLit "guestStringLiteral")  hetmet_guest_string_literal_key
 816 hetmet_guest_char_literal_name    = varQual gHC_HETMET_CODETYPES (fsLit "guestCharLiteral")    hetmet_guest_char_literal_key
 817
 818 hetmet_PGArrow_name :: Name
 819 hetmet_PGArrow_name = tcQual gHC_HETMET_PRIVATE (fsLit "PGArrow") hetmet_PGArrow_key
 820 hetmet_pga_id_name :: Name
 821 hetmet_pga_id_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_id") hetmet_pga_id_key
 822 hetmet_pga_comp_name :: Name
 823 hetmet_pga_comp_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_comp") hetmet_pga_comp_key
 824 hetmet_pga_first_name :: Name
 825 hetmet_pga_first_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_first") hetmet_pga_first_key
 826 hetmet_pga_second_name :: Name
 827 hetmet_pga_second_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_second") hetmet_pga_second_key
 828 hetmet_pga_cancell_name :: Name
 829 hetmet_pga_cancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancell") hetmet_pga_cancell_key
 830 hetmet_pga_cancelr_name :: Name
 831 hetmet_pga_cancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancelr") hetmet_pga_cancelr_key
 832 hetmet_pga_uncancell_name :: Name
 833 hetmet_pga_uncancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancell") hetmet_pga_uncancell_key
 834 hetmet_pga_uncancelr_name :: Name
 835 hetmet_pga_uncancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancelr") hetmet_pga_uncancelr_key
 836 hetmet_pga_assoc_name :: Name
 837 hetmet_pga_assoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_assoc") hetmet_pga_assoc_key
 838 hetmet_pga_unassoc_name :: Name
 839 hetmet_pga_unassoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_unassoc") hetmet_pga_unassoc_key
 840 hetmet_pga_copy_name :: Name
 841 hetmet_pga_copy_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_copy") hetmet_pga_copy_key
 842 hetmet_pga_drop_name :: Name
 843 hetmet_pga_drop_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_drop") hetmet_pga_drop_key
 844 hetmet_pga_swap_name :: Name
 845 hetmet_pga_swap_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_swap") hetmet_pga_swap_key
 846 hetmet_pga_applyl_name :: Name
 847 hetmet_pga_applyl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyl") hetmet_pga_applyl_key
 848 hetmet_pga_applyr_name :: Name
 849 hetmet_pga_applyr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyr") hetmet_pga_applyr_key
 850 hetmet_pga_curryl_name :: Name
 851 hetmet_pga_curryl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryl") hetmet_pga_curryl_key
 852 hetmet_pga_curryr_name :: Name
 853 hetmet_pga_curryr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryr") hetmet_pga_curryr_key
 854
 855 -- IO things
 856 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
 857     failIOName :: Name
 858 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
 859 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
 860 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
 861 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
 862 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
 863 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
 864
 865 -- IO things
 866 printName :: Name
 867 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
 868
 869 -- Int, Word, and Addr things
 870 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
 871 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
 872 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
 873 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
 874 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
 875
 876 -- Word module
 877 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 878     wordTyConName, wordDataConName :: Name
 879 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
 880 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
 881 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
 882 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
 883 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
 884 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
 885
 886 -- PrelPtr module
 887 ptrTyConName, funPtrTyConName :: Name
 888 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
 889 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
 890
 891 -- Foreign objects and weak pointers
 892 stablePtrTyConName, newStablePtrName :: Name
 893 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
 894 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
 895
 896 -- PrelST module
 897 runSTRepName :: Name
 898 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
 899
 900 -- Recursive-do notation
 901 monadFixClassName, mfixName :: Name
 902 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
 903 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
 904
 905 -- Arrow notation
 906 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
 907 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
 908 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
 909 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
 910 appAName           = varQual aRROW (fsLit "app")          appAIdKey
 911 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
 912 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
 913
 914 -- Annotation type checking
 915 toAnnotationWrapperName :: Name
 916 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
 917
 918 -- Other classes, needed for type defaulting
 919 monadPlusClassName, randomClassName, randomGenClassName,
 920     isStringClassName :: Name
 921 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 922 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 923 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 924 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 925
 926 -- dotnet interop
 927 objectTyConName :: Name
 928 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 929         -- objectTyConName was "wTcQual", but that's gone now, and
 930         -- I can't see why it was wired in anyway...
 931 unmarshalObjectName, marshalObjectName, marshalStringName,
 932     unmarshalStringName, checkDotnetResName :: Name
 933 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 934 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 935 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 936 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 937 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 938 \end{code}
 939
 940 %************************************************************************
 941 %*                                                                      *
 942 \subsection{Local helpers}
 943 %*                                                                      *
 944 %************************************************************************
 945
 946 All these are original names; hence mkOrig
 947
 948 \begin{code}
 949 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 950 varQual  = mk_known_key_name varName
 951 tcQual   = mk_known_key_name tcName
 952 clsQual  = mk_known_key_name clsName
 953
 954 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 955 mk_known_key_name space modu str unique
 956   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 957
 958 conName :: Module -> FastString -> Unique -> Name
 959 conName modu occ unique
 960   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
 961
 962 methName :: Module -> FastString -> Unique -> Name
 963 methName modu occ unique
 964   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
 965 \end{code}
 966
 967 %************************************************************************
 968 %*                                                                      *
 969 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 970 %*                                                                      *
 971 %************************************************************************
 972 --MetaHaskell extension hand allocate keys here
 973
 974 \begin{code}
 975 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
 976     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
 977     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
 978     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
 979 boundedClassKey         = mkPreludeClassUnique 1
 980 enumClassKey            = mkPreludeClassUnique 2
 981 eqClassKey              = mkPreludeClassUnique 3
 982 floatingClassKey        = mkPreludeClassUnique 5
 983 fractionalClassKey      = mkPreludeClassUnique 6
 984 integralClassKey        = mkPreludeClassUnique 7
 985 monadClassKey           = mkPreludeClassUnique 8
 986 dataClassKey            = mkPreludeClassUnique 9
 987 functorClassKey         = mkPreludeClassUnique 10
 988 numClassKey             = mkPreludeClassUnique 11
 989 ordClassKey             = mkPreludeClassUnique 12
 990 readClassKey            = mkPreludeClassUnique 13
 991 realClassKey            = mkPreludeClassUnique 14
 992 realFloatClassKey       = mkPreludeClassUnique 15
 993 realFracClassKey        = mkPreludeClassUnique 16
 994 showClassKey            = mkPreludeClassUnique 17
 995 ixClassKey              = mkPreludeClassUnique 18
 996
 997 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
 998     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
 999     :: Unique
1000 typeableClassKey        = mkPreludeClassUnique 20
1001 typeable1ClassKey       = mkPreludeClassUnique 21
1002 typeable2ClassKey       = mkPreludeClassUnique 22
1003 typeable3ClassKey       = mkPreludeClassUnique 23
1004 typeable4ClassKey       = mkPreludeClassUnique 24
1005 typeable5ClassKey       = mkPreludeClassUnique 25
1006 typeable6ClassKey       = mkPreludeClassUnique 26
1007 typeable7ClassKey       = mkPreludeClassUnique 27
1008
1009 monadFixClassKey :: Unique
1010 monadFixClassKey        = mkPreludeClassUnique 28
1011
1012 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1013 monadPlusClassKey       = mkPreludeClassUnique 30
1014 randomClassKey          = mkPreludeClassUnique 31
1015 randomGenClassKey       = mkPreludeClassUnique 32
1016
1017 isStringClassKey :: Unique
1018 isStringClassKey        = mkPreludeClassUnique 33
1019
1020 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1021 applicativeClassKey     = mkPreludeClassUnique 34
1022 foldableClassKey        = mkPreludeClassUnique 35
1023 traversableClassKey     = mkPreludeClassUnique 36
1024 \end{code}
1025
1026 %************************************************************************
1027 %*                                                                      *
1028 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1029 %*                                                                      *
1030 %************************************************************************
1031
1032 \begin{code}
1033 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1034     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1035     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1036     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1037     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1038     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1039     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1040     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1041     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1042     anyTyConKey :: Unique
1043 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1044 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1045 boolTyConKey                            = mkPreludeTyConUnique  4
1046 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1047 charPrimTyConKey                        = mkPreludeTyConUnique  7
1048 charTyConKey                            = mkPreludeTyConUnique  8
1049 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1050 doubleTyConKey                          = mkPreludeTyConUnique 10
1051 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1052 floatTyConKey                           = mkPreludeTyConUnique 12
1053 funTyConKey                             = mkPreludeTyConUnique 13
1054 intPrimTyConKey                         = mkPreludeTyConUnique 14
1055 intTyConKey                             = mkPreludeTyConUnique 15
1056 int8TyConKey                            = mkPreludeTyConUnique 16
1057 int16TyConKey                           = mkPreludeTyConUnique 17
1058 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1059 int32TyConKey                           = mkPreludeTyConUnique 19
1060 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1061 int64TyConKey                           = mkPreludeTyConUnique 21
1062 integerTyConKey                         = mkPreludeTyConUnique 22
1063 listTyConKey                            = mkPreludeTyConUnique 23
1064 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
1065 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1066 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1067 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1068 orderingTyConKey                        = mkPreludeTyConUnique 30
1069 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1070 ratioTyConKey                           = mkPreludeTyConUnique 32
1071 rationalTyConKey                        = mkPreludeTyConUnique 33
1072 realWorldTyConKey                       = mkPreludeTyConUnique 34
1073 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1074 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1075 anyTyConKey                             = mkPreludeTyConUnique 37
1076
1077 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1078     mutVarPrimTyConKey, ioTyConKey,
1079     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1080     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1081     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1082     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1083     funPtrTyConKey, tVarPrimTyConKey :: Unique
1084 statePrimTyConKey                       = mkPreludeTyConUnique 50
1085 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1086 stableNameTyConKey                      = mkPreludeTyConUnique 52
1087 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1088 ioTyConKey                              = mkPreludeTyConUnique 56
1089 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1090 wordTyConKey                            = mkPreludeTyConUnique 59
1091 word8TyConKey                           = mkPreludeTyConUnique 60
1092 word16TyConKey                          = mkPreludeTyConUnique 61
1093 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1094 word32TyConKey                          = mkPreludeTyConUnique 63
1095 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1096 word64TyConKey                          = mkPreludeTyConUnique 65
1097 liftedConKey                            = mkPreludeTyConUnique 66
1098 unliftedConKey                          = mkPreludeTyConUnique 67
1099 anyBoxConKey                            = mkPreludeTyConUnique 68
1100 kindConKey                              = mkPreludeTyConUnique 69
1101 boxityConKey                            = mkPreludeTyConUnique 70
1102 typeConKey                              = mkPreludeTyConUnique 71
1103 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1104 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1105 ptrTyConKey                             = mkPreludeTyConUnique 74
1106 funPtrTyConKey                          = mkPreludeTyConUnique 75
1107 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1108
1109 -- Generic Type Constructors
1110 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1111 crossTyConKey                           = mkPreludeTyConUnique 79
1112 plusTyConKey                            = mkPreludeTyConUnique 80
1113 genUnitTyConKey                         = mkPreludeTyConUnique 81
1114
1115 -- Parallel array type constructor
1116 parrTyConKey :: Unique
1117 parrTyConKey                            = mkPreludeTyConUnique 82
1118
1119 -- dotnet interop
1120 objectTyConKey :: Unique
1121 objectTyConKey                          = mkPreludeTyConUnique 83
1122
1123 eitherTyConKey :: Unique
1124 eitherTyConKey                          = mkPreludeTyConUnique 84
1125
1126 -- Super Kinds constructors
1127 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1128 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
1129 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
1130
1131 -- Kind constructors
1132 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1133     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1134 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1135 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1136 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1137 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1138 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1139
1140 -- Coercion constructors
1141 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1142     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1143     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1144     :: Unique
1145 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1146 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1147 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1148 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1149 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1150 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1151 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1152 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1153 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1154
1155 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1156     opaqueTyConKey :: Unique
1157 unknownTyConKey                         = mkPreludeTyConUnique 129
1158 unknown1TyConKey                        = mkPreludeTyConUnique 130
1159 unknown2TyConKey                        = mkPreludeTyConUnique 131
1160 unknown3TyConKey                        = mkPreludeTyConUnique 132
1161 opaqueTyConKey                          = mkPreludeTyConUnique 133
1162
1163 stringTyConKey :: Unique
1164 stringTyConKey                          = mkPreludeTyConUnique 134
1165
1166 -- Heterogeneous Metaprogramming code type constructor
1167 hetMetCodeTypeTyConKey :: Unique
1168 hetMetCodeTypeTyConKey                  = mkPreludeTyConUnique 135
1169
1170 ---------------- Template Haskell -------------------
1171 --      USES TyConUniques 200-299
1172 -----------------------------------------------------
1173
1174 unitTyConKey :: Unique
1175 unitTyConKey = mkTupleTyConUnique Boxed 0
1176 \end{code}
1177
1178 %************************************************************************
1179 %*                                                                      *
1180 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1181 %*                                                                      *
1182 %************************************************************************
1183
1184 \begin{code}
1185 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1186     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1187     stableNameDataConKey, trueDataConKey, wordDataConKey,
1188     ioDataConKey, integerDataConKey :: Unique
1189 charDataConKey                          = mkPreludeDataConUnique  1
1190 consDataConKey                          = mkPreludeDataConUnique  2
1191 doubleDataConKey                        = mkPreludeDataConUnique  3
1192 falseDataConKey                         = mkPreludeDataConUnique  4
1193 floatDataConKey                         = mkPreludeDataConUnique  5
1194 intDataConKey                           = mkPreludeDataConUnique  6
1195 nilDataConKey                           = mkPreludeDataConUnique 11
1196 ratioDataConKey                         = mkPreludeDataConUnique 12
1197 stableNameDataConKey                    = mkPreludeDataConUnique 14
1198 trueDataConKey                          = mkPreludeDataConUnique 15
1199 wordDataConKey                          = mkPreludeDataConUnique 16
1200 ioDataConKey                            = mkPreludeDataConUnique 17
1201 integerDataConKey                       = mkPreludeDataConUnique 18
1202
1203 -- Generic data constructors
1204 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1205 crossDataConKey                         = mkPreludeDataConUnique 20
1206 inlDataConKey                           = mkPreludeDataConUnique 21
1207 inrDataConKey                           = mkPreludeDataConUnique 22
1208 genUnitDataConKey                       = mkPreludeDataConUnique 23
1209
1210 -- Data constructor for parallel arrays
1211 parrDataConKey :: Unique
1212 parrDataConKey                          = mkPreludeDataConUnique 24
1213
1214 leftDataConKey, rightDataConKey :: Unique
1215 leftDataConKey                          = mkPreludeDataConUnique 25
1216 rightDataConKey                         = mkPreludeDataConUnique 26
1217
1218 -- Data constructor for Heterogeneous Metaprogramming code types
1219 hetMetCodeTypeDataConKey :: Unique
1220 hetMetCodeTypeDataConKey                        = mkPreludeDataConUnique 27
1221 \end{code}
1222
1223 %************************************************************************
1224 %*                                                                      *
1225 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1226 %*                                                                      *
1227 %************************************************************************
1228
1229 \begin{code}
1230 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1231     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1232     integerMinusOneIdKey, integerPlusOneIdKey,
1233     integerPlusTwoIdKey, integerZeroIdKey,
1234     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1235     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1236     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1237     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1238     traceIdKey, wildCardKey,
1239     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1240     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1241 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1242 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1243 augmentIdKey                  = mkPreludeMiscIdUnique  3
1244 appendIdKey                   = mkPreludeMiscIdUnique  4
1245 buildIdKey                    = mkPreludeMiscIdUnique  5
1246 errorIdKey                    = mkPreludeMiscIdUnique  6
1247 foldlIdKey                    = mkPreludeMiscIdUnique  7
1248 foldrIdKey                    = mkPreludeMiscIdUnique  8
1249 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1250 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1251 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1252 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1253 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1254 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1255 seqIdKey                      = mkPreludeMiscIdUnique 15
1256 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1257 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1258 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1259 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1260 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1261 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1262 parIdKey                      = mkPreludeMiscIdUnique 22
1263 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1264 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1265 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1266 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1267 traceIdKey                    = mkPreludeMiscIdUnique 27
1268 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1269 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1270 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1271 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1272
1273 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1274     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1275     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1276     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1277     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1278 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1279 concatIdKey                   = mkPreludeMiscIdUnique 33
1280 filterIdKey                   = mkPreludeMiscIdUnique 34
1281 zipIdKey                      = mkPreludeMiscIdUnique 35
1282 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1283 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1284 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1285 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1286 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1287 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1288 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1289 printIdKey                    = mkPreludeMiscIdUnique 43
1290 failIOIdKey                   = mkPreludeMiscIdUnique 44
1291 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1292 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1293 fstIdKey                      = mkPreludeMiscIdUnique 49
1294 sndIdKey                      = mkPreludeMiscIdUnique 50
1295 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1296 assertIdKey                   = mkPreludeMiscIdUnique 53
1297 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1298
1299 rootMainKey, runMainKey :: Unique
1300 rootMainKey                   = mkPreludeMiscIdUnique 55
1301 runMainKey                    = mkPreludeMiscIdUnique 56
1302
1303 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1304 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1305 lazyIdKey                     = mkPreludeMiscIdUnique 60
1306 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1307
1308 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1309     breakpointJumpIdKey, breakpointCondJumpIdKey,
1310     breakpointAutoJumpIdKey :: Unique
1311 breakpointIdKey               = mkPreludeMiscIdUnique 62
1312 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1313 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1314 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1315 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1316 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1317
1318 inlineIdKey :: Unique
1319 inlineIdKey                   = mkPreludeMiscIdUnique 68
1320
1321 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1322 mapIdKey              = mkPreludeMiscIdUnique 69
1323 groupWithIdKey        = mkPreludeMiscIdUnique 70
1324 dollarIdKey           = mkPreludeMiscIdUnique 71
1325
1326 -- Parallel array functions
1327 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1328     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1329     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1330 singletonPIdKey               = mkPreludeMiscIdUnique 79
1331 nullPIdKey                    = mkPreludeMiscIdUnique 80
1332 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1333 replicatePIdKey               = mkPreludeMiscIdUnique 82
1334 mapPIdKey                     = mkPreludeMiscIdUnique 83
1335 filterPIdKey                  = mkPreludeMiscIdUnique 84
1336 zipPIdKey                     = mkPreludeMiscIdUnique 85
1337 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1338 indexPIdKey                   = mkPreludeMiscIdUnique 87
1339 toPIdKey                      = mkPreludeMiscIdUnique 88
1340 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1341 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1342 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1343 appPIdKey                     = mkPreludeMiscIdUnique 92
1344
1345 -- dotnet interop
1346 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1347     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1348 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1349 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1350 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1351 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1352 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1353
1354 \end{code}
1355
1356 Certain class operations from Prelude classes.  They get their own
1357 uniques so we can look them up easily when we want to conjure them up
1358 during type checking.
1359
1360 \begin{code}
1361         -- Just a place holder for  unbound variables  produced by the renamer:
1362 unboundKey :: Unique
1363 unboundKey                    = mkPreludeMiscIdUnique 101
1364
1365 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1366     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1367     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1368     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1369     :: Unique
1370 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1371 minusClassOpKey               = mkPreludeMiscIdUnique 103
1372 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1373 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1374 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1375 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1376 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1377 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1378 geClassOpKey                  = mkPreludeMiscIdUnique 110
1379 negateClassOpKey              = mkPreludeMiscIdUnique 111
1380 failMClassOpKey               = mkPreludeMiscIdUnique 112
1381 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1382 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1383 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1384
1385 -- Recursive do notation
1386 mfixIdKey :: Unique
1387 mfixIdKey       = mkPreludeMiscIdUnique 118
1388
1389 -- Arrow notation
1390 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1391     loopAIdKey :: Unique
1392 arrAIdKey       = mkPreludeMiscIdUnique 119
1393 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1394 firstAIdKey     = mkPreludeMiscIdUnique 121
1395 appAIdKey       = mkPreludeMiscIdUnique 122
1396 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1397 loopAIdKey      = mkPreludeMiscIdUnique 124
1398
1399 fromStringClassOpKey :: Unique
1400 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1401
1402 -- Annotation type checking
1403 toAnnotationWrapperIdKey :: Unique
1404 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 126
1405
1406 -- Conversion functions
1407 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1408 fromIntegralIdKey    = mkPreludeMiscIdUnique 127
1409 realToFracIdKey      = mkPreludeMiscIdUnique 128
1410 toIntegerClassOpKey  = mkPreludeMiscIdUnique 129
1411 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1412
1413 -- code types
1414 hetmet_brak_key, hetmet_esc_key, hetmet_csp_key, hetmet_flatten_key, hetmet_unflatten_key, hetmet_flattened_id_key :: Unique
1415 hetmet_brak_key    = mkPreludeMiscIdUnique 131
1416 hetmet_esc_key     = mkPreludeMiscIdUnique 132
1417 hetmet_csp_key     = mkPreludeMiscIdUnique 133
1418 hetmet_guest_integer_literal_key, hetmet_guest_string_literal_key, hetmet_guest_char_literal_key :: Unique
1419 hetmet_guest_integer_literal_key = mkPreludeMiscIdUnique 134
1420 hetmet_guest_string_literal_key  = mkPreludeMiscIdUnique 135
1421 hetmet_guest_char_literal_key    = mkPreludeMiscIdUnique 136
1422 hetmet_PGArrow_key :: Unique
1423 hetmet_PGArrow_key = mkPreludeMiscIdUnique 137
1424 hetmet_pga_id_key :: Unique
1425 hetmet_pga_id_key = mkPreludeMiscIdUnique 138
1426 hetmet_pga_comp_key :: Unique
1427 hetmet_pga_comp_key = mkPreludeMiscIdUnique 139
1428 hetmet_pga_first_key :: Unique
1429 hetmet_pga_first_key = mkPreludeMiscIdUnique 140
1430 hetmet_pga_second_key :: Unique
1431 hetmet_pga_second_key = mkPreludeMiscIdUnique 141
1432 hetmet_pga_cancell_key :: Unique
1433 hetmet_pga_cancell_key = mkPreludeMiscIdUnique 142
1434 hetmet_pga_cancelr_key :: Unique
1435 hetmet_pga_cancelr_key = mkPreludeMiscIdUnique 143
1436 hetmet_pga_uncancell_key :: Unique
1437 hetmet_pga_uncancell_key = mkPreludeMiscIdUnique 144
1438 hetmet_pga_uncancelr_key :: Unique
1439 hetmet_pga_uncancelr_key = mkPreludeMiscIdUnique 145
1440 hetmet_pga_assoc_key :: Unique
1441 hetmet_pga_assoc_key = mkPreludeMiscIdUnique 146
1442 hetmet_pga_unassoc_key :: Unique
1443 hetmet_pga_unassoc_key = mkPreludeMiscIdUnique 147
1444 hetmet_pga_copy_key :: Unique
1445 hetmet_pga_copy_key = mkPreludeMiscIdUnique 148
1446 hetmet_pga_drop_key :: Unique
1447 hetmet_pga_drop_key = mkPreludeMiscIdUnique 149
1448 hetmet_pga_swap_key :: Unique
1449 hetmet_pga_swap_key = mkPreludeMiscIdUnique 150
1450 hetmet_pga_applyl_key :: Unique
1451 hetmet_pga_applyl_key = mkPreludeMiscIdUnique 151
1452 hetmet_pga_applyr_key :: Unique
1453 hetmet_pga_applyr_key = mkPreludeMiscIdUnique 152
1454 hetmet_pga_curryl_key :: Unique
1455 hetmet_pga_curryl_key = mkPreludeMiscIdUnique 153
1456 hetmet_pga_curryr_key :: Unique
1457 hetmet_pga_curryr_key = mkPreludeMiscIdUnique 154
1458 hetmet_flatten_key = mkPreludeMiscIdUnique 155
1459 hetmet_unflatten_key = mkPreludeMiscIdUnique 156
1460 hetmet_flattened_id_key = mkPreludeMiscIdUnique 157
1461
1462
1463
1464 ---------------- Template Haskell -------------------
1465 --      USES IdUniques 200-499
1466 -----------------------------------------------------
1467 \end{code}
1468
1469
1470 %************************************************************************
1471 %*                                                                      *
1472 \subsection{Standard groups of types}
1473 %*                                                                      *
1474 %************************************************************************
1475
1476 \begin{code}
1477 numericTyKeys :: [Unique]
1478 numericTyKeys =
1479         [ wordTyConKey
1480         , intTyConKey
1481         , integerTyConKey
1482         , doubleTyConKey
1483         , floatTyConKey
1484         ]
1485
1486 kindKeys :: [Unique]
1487 kindKeys = [ liftedTypeKindTyConKey
1488            , openTypeKindTyConKey
1489            , unliftedTypeKindTyConKey
1490            , ubxTupleKindTyConKey
1491            , argTypeKindTyConKey ]
1492 \end{code}
1493
1494
1495 %************************************************************************
1496 %*                                                                      *
1497 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1498 %*                                                                      *
1499 %************************************************************************
1500
1501 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1502 even though every numeric class has these two as a superclass,
1503 because the list of ambiguous dictionaries hasn't been simplified.
1504
1505 \begin{code}
1506 numericClassKeys :: [Unique]
1507 numericClassKeys =
1508         [ numClassKey
1509         , realClassKey
1510         , integralClassKey
1511         ]
1512         ++ fractionalClassKeys
1513
1514 fractionalClassKeys :: [Unique]
1515 fractionalClassKeys =
1516         [ fractionalClassKey
1517         , floatingClassKey
1518         , realFracClassKey
1519         , realFloatClassKey
1520         ]
1521
1522         -- the strictness analyser needs to know about numeric types
1523         -- (see SaAbsInt.lhs)
1524 needsDataDeclCtxtClassKeys :: [Unique]
1525 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1526         [ readClassKey
1527         ]
1528
1529 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1530 -- and are: "classes defined in the Prelude or a standard library"
1531 standardClassKeys :: [Unique]
1532 standardClassKeys = derivableClassKeys ++ numericClassKeys
1533                   ++ [randomClassKey, randomGenClassKey,
1534                       functorClassKey,
1535                       monadClassKey, monadPlusClassKey,
1536                       isStringClassKey,
1537                       applicativeClassKey, foldableClassKey, traversableClassKey
1538                      ]
1539 \end{code}
1540
1541 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1542 (@TcDeriv@).
1543
1544 \begin{code}
1545 derivableClassKeys :: [Unique]
1546 derivableClassKeys
1547   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1548       boundedClassKey, showClassKey, readClassKey ]
1549 \end{code}
1550