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