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