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