compiler/prelude/PrelNames.lhs

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