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 PackageConfig
  53 import Module     ( Module, ModuleName, mkModule, mkModuleNameFS )
  54 import OccName    ( dataName, tcName, clsName, varName, mkOccNameFS,
  55                     mkVarOccFS )
  56 import RdrName    ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
  57 import Unique     ( Unique, Uniquable(..), hasKey,
  58                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
  59                     mkPreludeTyConUnique, mkPreludeClassUnique,
  60                     mkTupleTyConUnique
  61                   )
  62 import BasicTypes ( Boxity(..), Arity )
  63 import Name       ( Name, mkInternalName, mkExternalName )
  64 import SrcLoc
  65 import FastString
  66 \end{code}
  67
  68
  69 %************************************************************************
  70 %*                                                                      *
  71 \subsection{Local Names}
  72 %*                                                                      *
  73 %************************************************************************
  74
  75 This *local* name is used by the interactive stuff
  76
  77 \begin{code}
  78 itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcSpan
  79 \end{code}
  80
  81 \begin{code}
  82 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
  83 -- during compiler debugging.
  84 mkUnboundName :: RdrName -> Name
  85 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan
  86
  87 isUnboundName :: Name -> Bool
  88 isUnboundName name = name `hasKey` unboundKey
  89 \end{code}
  90
  91
  92 %************************************************************************
  93 %*                                                                      *
  94 \subsection{Known key Names}
  95 %*                                                                      *
  96 %************************************************************************
  97
  98 This section tells what the compiler knows about the assocation of
  99 names with uniques.  These ones are the *non* wired-in ones.  The
 100 wired in ones are defined in TysWiredIn etc.
 101
 102 \begin{code}
 103 basicKnownKeyNames :: [Name]
 104 basicKnownKeyNames
 105  = genericTyConNames
 106  ++ typeableClassNames
 107  ++ ndpNames
 108  ++ [   -- Type constructors (synonyms especially)
 109         ioTyConName, ioDataConName,
 110         runMainIOName,
 111         orderingTyConName,
 112         rationalTyConName,
 113         stringTyConName,
 114         ratioDataConName,
 115         ratioTyConName,
 116         integerTyConName, smallIntegerDataConName, largeIntegerDataConName,
 117
 118         --  Classes.  *Must* include:
 119         --      classes that are grabbed by key (e.g., eqClassKey)
 120         --      classes in "Class.standardClassKeys" (quite a few)
 121         eqClassName,                    -- mentioned, derivable
 122         ordClassName,                   -- derivable
 123         boundedClassName,               -- derivable
 124         numClassName,                   -- mentioned, numeric
 125         enumClassName,                  -- derivable
 126         monadClassName,
 127         functorClassName,
 128         realClassName,                  -- numeric
 129         integralClassName,              -- numeric
 130         fractionalClassName,            -- numeric
 131         floatingClassName,              -- numeric
 132         realFracClassName,              -- numeric
 133         realFloatClassName,             -- numeric
 134         dataClassName,
 135         isStringClassName,
 136
 137         -- Numeric stuff
 138         negateName, minusName,
 139         fromRationalName, fromIntegerName,
 140         geName, eqName,
 141
 142         -- String stuff
 143         fromStringName,
 144
 145         -- Enum stuff
 146         enumFromName, enumFromThenName,
 147         enumFromThenToName, enumFromToName,
 148         enumFromToPName, enumFromThenToPName,
 149
 150         -- Monad stuff
 151         thenIOName, bindIOName, returnIOName, failIOName,
 152         failMName, bindMName, thenMName, returnMName,
 153
 154         -- MonadRec stuff
 155         mfixName,
 156
 157         -- Arrow stuff
 158         arrAName, composeAName, firstAName,
 159         appAName, choiceAName, loopAName,
 160
 161         -- Ix stuff
 162         ixClassName,
 163
 164         -- Show stuff
 165         showClassName,
 166
 167         -- Read stuff
 168         readClassName,
 169
 170         -- Stable pointers
 171         newStablePtrName,
 172
 173         -- Strings and lists
 174         unpackCStringName, unpackCStringAppendName,
 175         unpackCStringFoldrName, unpackCStringUtf8Name,
 176
 177         -- List operations
 178         concatName, filterName,
 179         zipName, foldrName, buildName, augmentName, appendName,
 180
 181         -- Parallel array operations
 182         nullPName, lengthPName, replicatePName, mapPName,
 183         filterPName, zipPName, crossMapPName, indexPName,
 184         toPName, bpermutePName, bpermuteDftPName, indexOfPName,
 185
 186         -- FFI primitive types that are not wired-in.
 187         stablePtrTyConName, ptrTyConName, funPtrTyConName,
 188         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
 189         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 190
 191         -- Others
 192         otherwiseIdName, inlineIdName,
 193         plusIntegerName, timesIntegerName,
 194         eqStringName, assertName, breakpointName, breakpointCondName,
 195         breakpointAutoName,  opaqueTyConName,
 196         assertErrorName, runSTRepName,
 197         printName, fstName, sndName,
 198
 199         -- MonadFix
 200         monadFixClassName, mfixName,
 201
 202         -- Other classes
 203         randomClassName, randomGenClassName, monadPlusClassName,
 204
 205         -- Booleans
 206         andName, orName
 207
 208         -- The Either type
 209         , eitherTyConName, leftDataConName, rightDataConName
 210
 211         -- dotnet interop
 212         , objectTyConName, marshalObjectName, unmarshalObjectName
 213         , marshalStringName, unmarshalStringName, checkDotnetResName
 214     ]
 215
 216 genericTyConNames :: [Name]
 217 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
 218
 219 ndpNames :: [Name]
 220 ndpNames = [ parrayTyConName, paTyConName, preprTyConName
 221            , ndpCrossTyConName, ndpPlusTyConName, embedTyConName
 222            , closureTyConName
 223            , mkClosureName, applyClosureName
 224            , mkClosurePName, applyClosurePName
 225            , lengthPAName, replicatePAName, emptyPAName, packPAName,
 226              combinePAName, intEqPAName ]
 227 \end{code}
 228
 229
 230 %************************************************************************
 231 %*                                                                      *
 232 \subsection{Module names}
 233 %*                                                                      *
 234 %************************************************************************
 235
 236
 237 --MetaHaskell Extension Add a new module here
 238 \begin{code}
 239 pRELUDE         = mkBaseModule_ pRELUDE_NAME
 240 gHC_PRIM        = mkBaseModule FSLIT("GHC.Prim")   -- Primitive types and values
 241 gHC_BASE        = mkBaseModule FSLIT("GHC.Base")
 242 gHC_ENUM        = mkBaseModule FSLIT("GHC.Enum")
 243 gHC_SHOW        = mkBaseModule FSLIT("GHC.Show")
 244 gHC_READ        = mkBaseModule FSLIT("GHC.Read")
 245 gHC_NUM         = mkBaseModule FSLIT("GHC.Num")
 246 gHC_LIST        = mkBaseModule FSLIT("GHC.List")
 247 gHC_PARR        = mkBaseModule FSLIT("GHC.PArr")
 248 dATA_TUP        = mkBaseModule FSLIT("Data.Tuple")
 249 dATA_EITHER     = mkBaseModule FSLIT("Data.Either")
 250 dATA_STRING     = mkBaseModule FSLIT("Data.String")
 251 gHC_PACK        = mkBaseModule FSLIT("GHC.Pack")
 252 gHC_CONC        = mkBaseModule FSLIT("GHC.Conc")
 253 gHC_IO_BASE     = mkBaseModule FSLIT("GHC.IOBase")
 254 gHC_ST          = mkBaseModule FSLIT("GHC.ST")
 255 gHC_ARR         = mkBaseModule FSLIT("GHC.Arr")
 256 gHC_STABLE      = mkBaseModule FSLIT("GHC.Stable")
 257 gHC_ADDR        = mkBaseModule FSLIT("GHC.Addr")
 258 gHC_PTR         = mkBaseModule FSLIT("GHC.Ptr")
 259 gHC_ERR         = mkBaseModule FSLIT("GHC.Err")
 260 gHC_REAL        = mkBaseModule FSLIT("GHC.Real")
 261 gHC_FLOAT       = mkBaseModule FSLIT("GHC.Float")
 262 gHC_TOP_HANDLER = mkBaseModule FSLIT("GHC.TopHandler")
 263 sYSTEM_IO       = mkBaseModule FSLIT("System.IO")
 264 dYNAMIC         = mkBaseModule FSLIT("Data.Dynamic")
 265 tYPEABLE        = mkBaseModule FSLIT("Data.Typeable")
 266 gENERICS        = mkBaseModule FSLIT("Data.Generics.Basics")
 267 dOTNET          = mkBaseModule FSLIT("GHC.Dotnet")
 268 rEAD_PREC       = mkBaseModule FSLIT("Text.ParserCombinators.ReadPrec")
 269 lEX             = mkBaseModule FSLIT("Text.Read.Lex")
 270 gHC_INT         = mkBaseModule FSLIT("GHC.Int")
 271 gHC_WORD        = mkBaseModule FSLIT("GHC.Word")
 272 mONAD           = mkBaseModule FSLIT("Control.Monad")
 273 mONAD_FIX       = mkBaseModule FSLIT("Control.Monad.Fix")
 274 aRROW           = mkBaseModule FSLIT("Control.Arrow")
 275 rANDOM          = mkBaseModule FSLIT("System.Random")
 276 gLA_EXTS        = mkBaseModule FSLIT("GHC.Exts")
 277
 278 nDP_PARRAY      = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.PArray")
 279 nDP_UTILS       = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Utils")
 280 nDP_CLOSURE     = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Closure")
 281 nDP_INSTANCES   = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Instances")
 282
 283 mAIN            = mkMainModule_ mAIN_NAME
 284 rOOT_MAIN       = mkMainModule FSLIT(":Main") -- Root module for initialisation
 285
 286         -- The ':xxx' makes a module name that the user can never
 287         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 288         -- module name still starts with a capital letter, which keeps
 289         -- the z-encoded version consistent.
 290 iNTERACTIVE    = mkMainModule FSLIT(":Interactive")
 291 thFAKE         = mkMainModule FSLIT(":THFake")
 292
 293 pRELUDE_NAME   = mkModuleNameFS FSLIT("Prelude")
 294 mAIN_NAME      = mkModuleNameFS FSLIT("Main")
 295
 296 mkBaseModule :: FastString -> Module
 297 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
 298
 299 mkBaseModule_ :: ModuleName -> Module
 300 mkBaseModule_ m = mkModule basePackageId m
 301
 302 mkNDPModule :: FastString -> Module
 303 mkNDPModule m = mkModule ndpPackageId (mkModuleNameFS m)
 304
 305 mkNDPModule_ :: ModuleName -> Module
 306 mkNDPModule_ m = mkModule ndpPackageId m
 307
 308 mkMainModule :: FastString -> Module
 309 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
 310
 311 mkMainModule_ :: ModuleName -> Module
 312 mkMainModule_ m = mkModule mainPackageId m
 313 \end{code}
 314
 315 %************************************************************************
 316 %*                                                                      *
 317 \subsection{Constructing the names of tuples
 318 %*                                                                      *
 319 %************************************************************************
 320
 321 \begin{code}
 322 mkTupleModule :: Boxity -> Arity -> Module
 323 mkTupleModule Boxed   0 = gHC_BASE
 324 mkTupleModule Boxed   _ = dATA_TUP
 325 mkTupleModule Unboxed _ = gHC_PRIM
 326 \end{code}
 327
 328
 329 %************************************************************************
 330 %*                                                                      *
 331                         RdrNames
 332 %*                                                                      *
 333 %************************************************************************
 334
 335 \begin{code}
 336 main_RDR_Unqual         = mkUnqual varName FSLIT("main")
 337         -- We definitely don't want an Orig RdrName, because
 338         -- main might, in principle, be imported into module Main
 339
 340 eq_RDR                  = nameRdrName eqName
 341 ge_RDR                  = nameRdrName geName
 342 ne_RDR                  = varQual_RDR  gHC_BASE FSLIT("/=")
 343 le_RDR                  = varQual_RDR  gHC_BASE FSLIT("<=")
 344 gt_RDR                  = varQual_RDR  gHC_BASE FSLIT(">")
 345 compare_RDR             = varQual_RDR  gHC_BASE FSLIT("compare")
 346 ltTag_RDR               = dataQual_RDR gHC_BASE FSLIT("LT")
 347 eqTag_RDR               = dataQual_RDR gHC_BASE FSLIT("EQ")
 348 gtTag_RDR               = dataQual_RDR gHC_BASE FSLIT("GT")
 349
 350 eqClass_RDR             = nameRdrName eqClassName
 351 numClass_RDR            = nameRdrName numClassName
 352 ordClass_RDR            = nameRdrName ordClassName
 353 enumClass_RDR           = nameRdrName enumClassName
 354 monadClass_RDR          = nameRdrName monadClassName
 355
 356 map_RDR                 = varQual_RDR gHC_BASE FSLIT("map")
 357 append_RDR              = varQual_RDR gHC_BASE FSLIT("++")
 358
 359 foldr_RDR               = nameRdrName foldrName
 360 build_RDR               = nameRdrName buildName
 361 returnM_RDR             = nameRdrName returnMName
 362 bindM_RDR               = nameRdrName bindMName
 363 failM_RDR               = nameRdrName failMName
 364
 365 and_RDR                 = nameRdrName andName
 366
 367 left_RDR                = nameRdrName leftDataConName
 368 right_RDR               = nameRdrName rightDataConName
 369
 370 fromEnum_RDR            = varQual_RDR gHC_ENUM FSLIT("fromEnum")
 371 toEnum_RDR              = varQual_RDR gHC_ENUM FSLIT("toEnum")
 372
 373 enumFrom_RDR            = nameRdrName enumFromName
 374 enumFromTo_RDR          = nameRdrName enumFromToName
 375 enumFromThen_RDR        = nameRdrName enumFromThenName
 376 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 377
 378 ratioDataCon_RDR        = nameRdrName ratioDataConName
 379 plusInteger_RDR         = nameRdrName plusIntegerName
 380 timesInteger_RDR        = nameRdrName timesIntegerName
 381
 382 ioDataCon_RDR           = nameRdrName ioDataConName
 383
 384 eqString_RDR            = nameRdrName eqStringName
 385 unpackCString_RDR       = nameRdrName unpackCStringName
 386 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 387 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 388
 389 newStablePtr_RDR        = nameRdrName newStablePtrName
 390 wordDataCon_RDR         = dataQual_RDR gHC_WORD FSLIT("W#")
 391
 392 bindIO_RDR              = nameRdrName bindIOName
 393 returnIO_RDR            = nameRdrName returnIOName
 394
 395 fromInteger_RDR         = nameRdrName fromIntegerName
 396 fromRational_RDR        = nameRdrName fromRationalName
 397 minus_RDR               = nameRdrName minusName
 398 times_RDR               = varQual_RDR  gHC_NUM FSLIT("*")
 399 plus_RDR                = varQual_RDR gHC_NUM FSLIT("+")
 400
 401 fromString_RDR          = nameRdrName fromStringName
 402
 403 compose_RDR             = varQual_RDR gHC_BASE FSLIT(".")
 404
 405 not_RDR                 = varQual_RDR gHC_BASE FSLIT("not")
 406 getTag_RDR              = varQual_RDR gHC_BASE FSLIT("getTag")
 407 succ_RDR                = varQual_RDR gHC_ENUM FSLIT("succ")
 408 pred_RDR                = varQual_RDR gHC_ENUM FSLIT("pred")
 409 minBound_RDR            = varQual_RDR gHC_ENUM FSLIT("minBound")
 410 maxBound_RDR            = varQual_RDR gHC_ENUM FSLIT("maxBound")
 411 range_RDR               = varQual_RDR gHC_ARR FSLIT("range")
 412 inRange_RDR             = varQual_RDR gHC_ARR FSLIT("inRange")
 413 index_RDR               = varQual_RDR gHC_ARR FSLIT("index")
 414 unsafeIndex_RDR         = varQual_RDR gHC_ARR FSLIT("unsafeIndex")
 415 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR FSLIT("unsafeRangeSize")
 416
 417 readList_RDR            = varQual_RDR gHC_READ FSLIT("readList")
 418 readListDefault_RDR     = varQual_RDR gHC_READ FSLIT("readListDefault")
 419 readListPrec_RDR        = varQual_RDR gHC_READ FSLIT("readListPrec")
 420 readListPrecDefault_RDR = varQual_RDR gHC_READ FSLIT("readListPrecDefault")
 421 readPrec_RDR            = varQual_RDR gHC_READ FSLIT("readPrec")
 422 parens_RDR              = varQual_RDR gHC_READ FSLIT("parens")
 423 choose_RDR              = varQual_RDR gHC_READ FSLIT("choose")
 424 lexP_RDR                = varQual_RDR gHC_READ FSLIT("lexP")
 425
 426 punc_RDR                = dataQual_RDR lEX FSLIT("Punc")
 427 ident_RDR               = dataQual_RDR lEX FSLIT("Ident")
 428 symbol_RDR              = dataQual_RDR lEX FSLIT("Symbol")
 429
 430 step_RDR                = varQual_RDR  rEAD_PREC FSLIT("step")
 431 alt_RDR                 = varQual_RDR  rEAD_PREC FSLIT("+++")
 432 reset_RDR               = varQual_RDR  rEAD_PREC FSLIT("reset")
 433 prec_RDR                = varQual_RDR  rEAD_PREC FSLIT("prec")
 434
 435 showList_RDR            = varQual_RDR gHC_SHOW FSLIT("showList")
 436 showList___RDR          = varQual_RDR gHC_SHOW FSLIT("showList__")
 437 showsPrec_RDR           = varQual_RDR gHC_SHOW FSLIT("showsPrec")
 438 showString_RDR          = varQual_RDR gHC_SHOW FSLIT("showString")
 439 showSpace_RDR           = varQual_RDR gHC_SHOW FSLIT("showSpace")
 440 showParen_RDR           = varQual_RDR gHC_SHOW FSLIT("showParen")
 441
 442 typeOf_RDR     = varQual_RDR tYPEABLE FSLIT("typeOf")
 443 mkTypeRep_RDR  = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
 444 mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
 445
 446 undefined_RDR = varQual_RDR gHC_ERR FSLIT("undefined")
 447
 448 crossDataCon_RDR   = dataQual_RDR gHC_BASE FSLIT(":*:")
 449 inlDataCon_RDR     = dataQual_RDR gHC_BASE FSLIT("Inl")
 450 inrDataCon_RDR     = dataQual_RDR gHC_BASE FSLIT("Inr")
 451 genUnitDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Unit")
 452
 453 ----------------------
 454 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
 455 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
 456 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
 457 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
 458 \end{code}
 459
 460 %************************************************************************
 461 %*                                                                      *
 462 \subsection{Known-key names}
 463 %*                                                                      *
 464 %************************************************************************
 465
 466 Many of these Names are not really "built in", but some parts of the
 467 compiler (notably the deriving mechanism) need to mention their names,
 468 and it's convenient to write them all down in one place.
 469
 470 --MetaHaskell Extension  add the constrs and the lower case case
 471 -- guys as well (perhaps) e.g. see  trueDataConName     below
 472
 473
 474 \begin{code}
 475 runMainIOName = varQual gHC_TOP_HANDLER FSLIT("runMainIO") runMainKey
 476
 477 orderingTyConName = tcQual   gHC_BASE FSLIT("Ordering") orderingTyConKey
 478
 479 eitherTyConName   = tcQual  dATA_EITHER FSLIT("Either") eitherTyConKey
 480 leftDataConName   = conName dATA_EITHER FSLIT("Left")   leftDataConKey
 481 rightDataConName  = conName dATA_EITHER FSLIT("Right")  rightDataConKey
 482
 483 -- Generics
 484 crossTyConName     = tcQual   gHC_BASE FSLIT(":*:") crossTyConKey
 485 plusTyConName      = tcQual   gHC_BASE FSLIT(":+:") plusTyConKey
 486 genUnitTyConName   = tcQual   gHC_BASE FSLIT("Unit") genUnitTyConKey
 487
 488 -- Base strings Strings
 489 unpackCStringName       = varQual gHC_BASE FSLIT("unpackCString#") unpackCStringIdKey
 490 unpackCStringAppendName = varQual gHC_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey
 491 unpackCStringFoldrName  = varQual gHC_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
 492 unpackCStringUtf8Name   = varQual gHC_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
 493 eqStringName            = varQual gHC_BASE FSLIT("eqString")  eqStringIdKey
 494 stringTyConName         = tcQual  gHC_BASE FSLIT("String") stringTyConKey
 495
 496 -- The 'inline' function
 497 inlineIdName            = varQual gHC_BASE FSLIT("inline") inlineIdKey
 498
 499 -- Base classes (Eq, Ord, Functor)
 500 eqClassName       = clsQual  gHC_BASE FSLIT("Eq")      eqClassKey
 501 eqName            = methName gHC_BASE FSLIT("==")      eqClassOpKey
 502 ordClassName      = clsQual  gHC_BASE FSLIT("Ord")     ordClassKey
 503 geName            = methName gHC_BASE FSLIT(">=")      geClassOpKey
 504 functorClassName  = clsQual  gHC_BASE FSLIT("Functor") functorClassKey
 505
 506 -- Class Monad
 507 monadClassName     = clsQual  gHC_BASE FSLIT("Monad")  monadClassKey
 508 thenMName          = methName gHC_BASE FSLIT(">>")     thenMClassOpKey
 509 bindMName          = methName gHC_BASE FSLIT(">>=")    bindMClassOpKey
 510 returnMName        = methName gHC_BASE FSLIT("return") returnMClassOpKey
 511 failMName          = methName gHC_BASE FSLIT("fail")   failMClassOpKey
 512
 513 -- Random PrelBase functions
 514 fromStringName = methName dATA_STRING FSLIT("fromString") fromStringClassOpKey
 515 otherwiseIdName   = varQual gHC_BASE FSLIT("otherwise")  otherwiseIdKey
 516 foldrName         = varQual gHC_BASE FSLIT("foldr")      foldrIdKey
 517 buildName         = varQual gHC_BASE FSLIT("build")      buildIdKey
 518 augmentName       = varQual gHC_BASE FSLIT("augment")    augmentIdKey
 519 appendName        = varQual gHC_BASE FSLIT("++")         appendIdKey
 520 andName           = varQual gHC_BASE FSLIT("&&")         andIdKey
 521 orName            = varQual gHC_BASE FSLIT("||")         orIdKey
 522 assertName        = varQual gHC_BASE FSLIT("assert")     assertIdKey
 523 breakpointName    = varQual gHC_BASE FSLIT("breakpoint") breakpointIdKey
 524 breakpointCondName= varQual gHC_BASE FSLIT("breakpointCond") breakpointCondIdKey
 525 breakpointAutoName= varQual gHC_BASE FSLIT("breakpointAuto") breakpointAutoIdKey
 526 opaqueTyConName   = tcQual  gHC_BASE FSLIT("Opaque")   opaqueTyConKey
 527
 528 breakpointJumpName
 529     = mkInternalName
 530         breakpointJumpIdKey
 531         (mkOccNameFS varName FSLIT("breakpointJump"))
 532         noSrcSpan
 533 breakpointCondJumpName
 534     = mkInternalName
 535         breakpointCondJumpIdKey
 536         (mkOccNameFS varName FSLIT("breakpointCondJump"))
 537         noSrcSpan
 538 breakpointAutoJumpName
 539     = mkInternalName
 540         breakpointAutoJumpIdKey
 541         (mkOccNameFS varName FSLIT("breakpointAutoJump"))
 542         noSrcSpan
 543
 544 -- PrelTup
 545 fstName           = varQual dATA_TUP FSLIT("fst") fstIdKey
 546 sndName           = varQual dATA_TUP FSLIT("snd") sndIdKey
 547
 548 -- Module PrelNum
 549 numClassName      = clsQual  gHC_NUM FSLIT("Num") numClassKey
 550 fromIntegerName   = methName gHC_NUM FSLIT("fromInteger") fromIntegerClassOpKey
 551 minusName         = methName gHC_NUM FSLIT("-") minusClassOpKey
 552 negateName        = methName gHC_NUM FSLIT("negate") negateClassOpKey
 553 plusIntegerName   = varQual  gHC_NUM FSLIT("plusInteger") plusIntegerIdKey
 554 timesIntegerName  = varQual  gHC_NUM FSLIT("timesInteger") timesIntegerIdKey
 555 integerTyConName  = tcQual   gHC_NUM FSLIT("Integer") integerTyConKey
 556 smallIntegerDataConName = conName gHC_NUM FSLIT("S#") smallIntegerDataConKey
 557 largeIntegerDataConName = conName gHC_NUM FSLIT("J#") largeIntegerDataConKey
 558
 559 -- PrelReal types and classes
 560 rationalTyConName   = tcQual  gHC_REAL FSLIT("Rational") rationalTyConKey
 561 ratioTyConName      = tcQual  gHC_REAL FSLIT("Ratio") ratioTyConKey
 562 ratioDataConName    = conName gHC_REAL FSLIT(":%") ratioDataConKey
 563 realClassName       = clsQual gHC_REAL FSLIT("Real") realClassKey
 564 integralClassName   = clsQual gHC_REAL FSLIT("Integral") integralClassKey
 565 realFracClassName   = clsQual gHC_REAL FSLIT("RealFrac") realFracClassKey
 566 fractionalClassName = clsQual gHC_REAL FSLIT("Fractional") fractionalClassKey
 567 fromRationalName    = methName gHC_REAL  FSLIT("fromRational") fromRationalClassOpKey
 568
 569 -- PrelFloat classes
 570 floatingClassName  = clsQual  gHC_FLOAT FSLIT("Floating") floatingClassKey
 571 realFloatClassName = clsQual  gHC_FLOAT FSLIT("RealFloat") realFloatClassKey
 572
 573 -- Class Ix
 574 ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey
 575
 576 -- Class Typeable
 577 typeableClassName  = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey
 578 typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey
 579 typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey
 580 typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey
 581 typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey
 582 typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey
 583 typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey
 584 typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey
 585
 586 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 587                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 588                         , typeable6ClassName, typeable7ClassName ]
 589
 590 -- Class Data
 591 dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
 592
 593 -- Error module
 594 assertErrorName   = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey
 595
 596 -- Enum module (Enum, Bounded)
 597 enumClassName      = clsQual gHC_ENUM FSLIT("Enum") enumClassKey
 598 enumFromName       = methName gHC_ENUM FSLIT("enumFrom") enumFromClassOpKey
 599 enumFromToName     = methName gHC_ENUM FSLIT("enumFromTo") enumFromToClassOpKey
 600 enumFromThenName   = methName gHC_ENUM FSLIT("enumFromThen") enumFromThenClassOpKey
 601 enumFromThenToName = methName gHC_ENUM FSLIT("enumFromThenTo") enumFromThenToClassOpKey
 602 boundedClassName   = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey
 603
 604 -- List functions
 605 concatName        = varQual gHC_LIST FSLIT("concat") concatIdKey
 606 filterName        = varQual gHC_LIST FSLIT("filter") filterIdKey
 607 zipName           = varQual gHC_LIST FSLIT("zip") zipIdKey
 608
 609 -- Class Show
 610 showClassName     = clsQual gHC_SHOW FSLIT("Show")       showClassKey
 611
 612 -- Class Read
 613 readClassName      = clsQual gHC_READ FSLIT("Read") readClassKey
 614
 615 -- parallel array types and functions
 616 enumFromToPName    = varQual gHC_PARR FSLIT("enumFromToP") enumFromToPIdKey
 617 enumFromThenToPName= varQual gHC_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey
 618 nullPName         = varQual gHC_PARR FSLIT("nullP")              nullPIdKey
 619 lengthPName       = varQual gHC_PARR FSLIT("lengthP")            lengthPIdKey
 620 replicatePName    = varQual gHC_PARR FSLIT("replicateP")         replicatePIdKey
 621 mapPName          = varQual gHC_PARR FSLIT("mapP")               mapPIdKey
 622 filterPName       = varQual gHC_PARR FSLIT("filterP")            filterPIdKey
 623 zipPName          = varQual gHC_PARR FSLIT("zipP")               zipPIdKey
 624 crossMapPName     = varQual gHC_PARR FSLIT("crossMapP")          crossMapPIdKey
 625 indexPName        = varQual gHC_PARR FSLIT("!:")                 indexPIdKey
 626 toPName           = varQual gHC_PARR FSLIT("toP")                toPIdKey
 627 bpermutePName     = varQual gHC_PARR FSLIT("bpermuteP")    bpermutePIdKey
 628 bpermuteDftPName  = varQual gHC_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey
 629 indexOfPName      = varQual gHC_PARR FSLIT("indexOfP")     indexOfPIdKey
 630
 631 -- IOBase things
 632 ioTyConName       = tcQual  gHC_IO_BASE FSLIT("IO") ioTyConKey
 633 ioDataConName     = conName gHC_IO_BASE FSLIT("IO") ioDataConKey
 634 thenIOName        = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey
 635 bindIOName        = varQual gHC_IO_BASE FSLIT("bindIO") bindIOIdKey
 636 returnIOName      = varQual gHC_IO_BASE FSLIT("returnIO") returnIOIdKey
 637 failIOName        = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey
 638
 639 -- IO things
 640 printName         = varQual sYSTEM_IO FSLIT("print") printIdKey
 641
 642 -- Int, Word, and Addr things
 643 int8TyConName     = tcQual gHC_INT  FSLIT("Int8") int8TyConKey
 644 int16TyConName    = tcQual gHC_INT  FSLIT("Int16") int16TyConKey
 645 int32TyConName    = tcQual gHC_INT  FSLIT("Int32") int32TyConKey
 646 int64TyConName    = tcQual gHC_INT  FSLIT("Int64") int64TyConKey
 647
 648 -- Word module
 649 word8TyConName    = tcQual  gHC_WORD FSLIT("Word8")  word8TyConKey
 650 word16TyConName   = tcQual  gHC_WORD FSLIT("Word16") word16TyConKey
 651 word32TyConName   = tcQual  gHC_WORD FSLIT("Word32") word32TyConKey
 652 word64TyConName   = tcQual  gHC_WORD FSLIT("Word64") word64TyConKey
 653 wordTyConName     = tcQual  gHC_WORD FSLIT("Word")   wordTyConKey
 654 wordDataConName   = conName gHC_WORD FSLIT("W#") wordDataConKey
 655
 656 -- PrelPtr module
 657 ptrTyConName      = tcQual   gHC_PTR FSLIT("Ptr") ptrTyConKey
 658 funPtrTyConName   = tcQual   gHC_PTR FSLIT("FunPtr") funPtrTyConKey
 659
 660 -- Foreign objects and weak pointers
 661 stablePtrTyConName    = tcQual   gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey
 662 newStablePtrName      = varQual  gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey
 663
 664 -- PrelST module
 665 runSTRepName       = varQual gHC_ST  FSLIT("runSTRep") runSTRepIdKey
 666
 667 -- Recursive-do notation
 668 monadFixClassName  = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
 669 mfixName           = methName mONAD_FIX FSLIT("mfix") mfixIdKey
 670
 671 -- Arrow notation
 672 arrAName           = varQual aRROW FSLIT("arr")   arrAIdKey
 673 composeAName       = varQual aRROW FSLIT(">>>")   composeAIdKey
 674 firstAName         = varQual aRROW FSLIT("first") firstAIdKey
 675 appAName           = varQual aRROW FSLIT("app")   appAIdKey
 676 choiceAName        = varQual aRROW FSLIT("|||")   choiceAIdKey
 677 loopAName          = varQual aRROW FSLIT("loop")  loopAIdKey
 678
 679 -- Other classes, needed for type defaulting
 680 monadPlusClassName  = clsQual mONAD FSLIT("MonadPlus")  monadPlusClassKey
 681 randomClassName     = clsQual rANDOM FSLIT("Random")    randomClassKey
 682 randomGenClassName  = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey
 683 isStringClassName   = clsQual dATA_STRING FSLIT("IsString") isStringClassKey
 684
 685 -- dotnet interop
 686 objectTyConName     = tcQual   dOTNET FSLIT("Object") objectTyConKey
 687         -- objectTyConName was "wTcQual", but that's gone now, and
 688         -- I can't see why it was wired in anyway...
 689 unmarshalObjectName = varQual  dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey
 690 marshalObjectName   = varQual  dOTNET FSLIT("marshalObject") marshalObjectIdKey
 691 marshalStringName   = varQual  dOTNET FSLIT("marshalString") marshalStringIdKey
 692 unmarshalStringName = varQual  dOTNET FSLIT("unmarshalString") unmarshalStringIdKey
 693 checkDotnetResName  = varQual  dOTNET FSLIT("checkResult")     checkDotnetResNameIdKey
 694
 695 -- NDP stuff
 696 parrayTyConName     = tcQual   nDP_PARRAY FSLIT("PArray") parrayTyConKey
 697 paTyConName         = tcQual   nDP_PARRAY FSLIT("PA")     paTyConKey
 698 preprTyConName      = tcQual   nDP_PARRAY FSLIT("PRepr")  preprTyConKey
 699 ndpCrossTyConName   = tcQual   nDP_PARRAY FSLIT(":*:")    ndpCrossTyConKey
 700 ndpPlusTyConName    = tcQual   nDP_PARRAY FSLIT(":+:")    ndpPlusTyConKey
 701 embedTyConName      = tcQual   nDP_PARRAY FSLIT("Embed")  embedTyConKey
 702 lengthPAName        = varQual  nDP_PARRAY FSLIT("lengthPA")    lengthPAIdKey
 703 replicatePAName     = varQual  nDP_PARRAY FSLIT("replicatePA") replicatePAIdKey
 704 emptyPAName         = varQual  nDP_PARRAY FSLIT("emptyPA") emptyPAIdKey
 705 packPAName          = varQual  nDP_PARRAY FSLIT("packPA")  packPAIdKey
 706 combinePAName       = varQual  nDP_PARRAY FSLIT("combinePA") combinePAIdKey
 707 intEqPAName         = varQual  nDP_UTILS  FSLIT("intEqPA") intEqPAIdKey
 708 closureTyConName    = tcQual   nDP_CLOSURE FSLIT(":->")    closureTyConKey
 709 mkClosureName       = varQual  nDP_CLOSURE FSLIT("mkClosure")  mkClosureIdKey
 710 applyClosureName    = varQual  nDP_CLOSURE FSLIT("$:")         applyClosureIdKey
 711 mkClosurePName      = varQual  nDP_CLOSURE FSLIT("mkClosureP") mkClosurePIdKey
 712 applyClosurePName   = varQual  nDP_CLOSURE FSLIT("$:^")        applyClosurePIdKey
 713 \end{code}
 714
 715 %************************************************************************
 716 %*                                                                      *
 717 \subsection{Local helpers}
 718 %*                                                                      *
 719 %************************************************************************
 720
 721 All these are original names; hence mkOrig
 722
 723 \begin{code}
 724 varQual  = mk_known_key_name varName
 725 tcQual   = mk_known_key_name tcName
 726 clsQual  = mk_known_key_name clsName
 727
 728 mk_known_key_name space mod str uniq
 729   = mkExternalName uniq mod (mkOccNameFS space str) noSrcSpan
 730
 731 conName :: Module -> FastString -> Unique -> Name
 732 conName mod occ uniq
 733   = mkExternalName uniq mod (mkOccNameFS dataName occ) noSrcSpan
 734
 735 methName :: Module -> FastString -> Unique -> Name
 736 methName mod occ uniq
 737   = mkExternalName uniq mod (mkVarOccFS occ) noSrcSpan
 738 \end{code}
 739
 740 %************************************************************************
 741 %*                                                                      *
 742 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 743 %*                                                                      *
 744 %************************************************************************
 745 --MetaHaskell extension hand allocate keys here
 746
 747 \begin{code}
 748 boundedClassKey         = mkPreludeClassUnique 1
 749 enumClassKey            = mkPreludeClassUnique 2
 750 eqClassKey              = mkPreludeClassUnique 3
 751 floatingClassKey        = mkPreludeClassUnique 5
 752 fractionalClassKey      = mkPreludeClassUnique 6
 753 integralClassKey        = mkPreludeClassUnique 7
 754 monadClassKey           = mkPreludeClassUnique 8
 755 dataClassKey            = mkPreludeClassUnique 9
 756 functorClassKey         = mkPreludeClassUnique 10
 757 numClassKey             = mkPreludeClassUnique 11
 758 ordClassKey             = mkPreludeClassUnique 12
 759 readClassKey            = mkPreludeClassUnique 13
 760 realClassKey            = mkPreludeClassUnique 14
 761 realFloatClassKey       = mkPreludeClassUnique 15
 762 realFracClassKey        = mkPreludeClassUnique 16
 763 showClassKey            = mkPreludeClassUnique 17
 764 ixClassKey              = mkPreludeClassUnique 18
 765
 766 typeableClassKey        = mkPreludeClassUnique 20
 767 typeable1ClassKey       = mkPreludeClassUnique 21
 768 typeable2ClassKey       = mkPreludeClassUnique 22
 769 typeable3ClassKey       = mkPreludeClassUnique 23
 770 typeable4ClassKey       = mkPreludeClassUnique 24
 771 typeable5ClassKey       = mkPreludeClassUnique 25
 772 typeable6ClassKey       = mkPreludeClassUnique 26
 773 typeable7ClassKey       = mkPreludeClassUnique 27
 774
 775 monadFixClassKey        = mkPreludeClassUnique 28
 776
 777 monadPlusClassKey       = mkPreludeClassUnique 30
 778 randomClassKey          = mkPreludeClassUnique 31
 779 randomGenClassKey       = mkPreludeClassUnique 32
 780
 781 isStringClassKey        = mkPreludeClassUnique 33
 782 \end{code}
 783
 784 %************************************************************************
 785 %*                                                                      *
 786 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 787 %*                                                                      *
 788 %************************************************************************
 789
 790 \begin{code}
 791 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 792 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 793 boolTyConKey                            = mkPreludeTyConUnique  4
 794 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 795 charPrimTyConKey                        = mkPreludeTyConUnique  7
 796 charTyConKey                            = mkPreludeTyConUnique  8
 797 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 798 doubleTyConKey                          = mkPreludeTyConUnique 10
 799 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 800 floatTyConKey                           = mkPreludeTyConUnique 12
 801 funTyConKey                             = mkPreludeTyConUnique 13
 802 intPrimTyConKey                         = mkPreludeTyConUnique 14
 803 intTyConKey                             = mkPreludeTyConUnique 15
 804 int8TyConKey                            = mkPreludeTyConUnique 16
 805 int16TyConKey                           = mkPreludeTyConUnique 17
 806 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 807 int32TyConKey                           = mkPreludeTyConUnique 19
 808 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 809 int64TyConKey                           = mkPreludeTyConUnique 21
 810 integerTyConKey                         = mkPreludeTyConUnique 22
 811 listTyConKey                            = mkPreludeTyConUnique 23
 812 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 813 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 814 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 815 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 816 orderingTyConKey                        = mkPreludeTyConUnique 30
 817 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 818 ratioTyConKey                           = mkPreludeTyConUnique 32
 819 rationalTyConKey                        = mkPreludeTyConUnique 33
 820 realWorldTyConKey                       = mkPreludeTyConUnique 34
 821 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 822 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 823
 824 anyPrimTyConKey                         = mkPreludeTyConUnique 37
 825 anyPrimTyCon1Key                        = mkPreludeTyConUnique 38
 826
 827 statePrimTyConKey                       = mkPreludeTyConUnique 50
 828 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 829 stableNameTyConKey                      = mkPreludeTyConUnique 52
 830 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 831 ioTyConKey                              = mkPreludeTyConUnique 56
 832 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 833 wordTyConKey                            = mkPreludeTyConUnique 59
 834 word8TyConKey                           = mkPreludeTyConUnique 60
 835 word16TyConKey                          = mkPreludeTyConUnique 61
 836 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 837 word32TyConKey                          = mkPreludeTyConUnique 63
 838 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 839 word64TyConKey                          = mkPreludeTyConUnique 65
 840 liftedConKey                            = mkPreludeTyConUnique 66
 841 unliftedConKey                          = mkPreludeTyConUnique 67
 842 anyBoxConKey                            = mkPreludeTyConUnique 68
 843 kindConKey                              = mkPreludeTyConUnique 69
 844 boxityConKey                            = mkPreludeTyConUnique 70
 845 typeConKey                              = mkPreludeTyConUnique 71
 846 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 847 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 848 ptrTyConKey                             = mkPreludeTyConUnique 74
 849 funPtrTyConKey                          = mkPreludeTyConUnique 75
 850 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
 851
 852 -- Generic Type Constructors
 853 crossTyConKey                           = mkPreludeTyConUnique 79
 854 plusTyConKey                            = mkPreludeTyConUnique 80
 855 genUnitTyConKey                         = mkPreludeTyConUnique 81
 856
 857 -- Parallel array type constructor
 858 parrTyConKey                            = mkPreludeTyConUnique 82
 859
 860 -- dotnet interop
 861 objectTyConKey                          = mkPreludeTyConUnique 83
 862
 863 eitherTyConKey                          = mkPreludeTyConUnique 84
 864
 865 -- Super Kinds constructors
 866 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
 867 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
 868
 869 -- Kind constructors
 870 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
 871 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
 872 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
 873 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
 874 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
 875
 876 -- Coercion constructors
 877 symCoercionTyConKey                     = mkPreludeTyConUnique 93
 878 transCoercionTyConKey                   = mkPreludeTyConUnique 94
 879 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
 880 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
 881 instCoercionTyConKey                    = mkPreludeTyConUnique 97
 882 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
 883
 884 unknownTyConKey                         = mkPreludeTyConUnique 99
 885 unknown1TyConKey                        = mkPreludeTyConUnique 130
 886 unknown2TyConKey                        = mkPreludeTyConUnique 131
 887 unknown3TyConKey                        = mkPreludeTyConUnique 132
 888 opaqueTyConKey                          = mkPreludeTyConUnique 133
 889
 890 stringTyConKey                          = mkPreludeTyConUnique 134
 891
 892 parrayTyConKey                          = mkPreludeTyConUnique 135
 893 closureTyConKey                         = mkPreludeTyConUnique 136
 894 paTyConKey                              = mkPreludeTyConUnique 137
 895 preprTyConKey                           = mkPreludeTyConUnique 138
 896 embedTyConKey                           = mkPreludeTyConUnique 139
 897 ndpCrossTyConKey                        = mkPreludeTyConUnique 140
 898 ndpPlusTyConKey                         = mkPreludeTyConUnique 141
 899
 900
 901 ---------------- Template Haskell -------------------
 902 --      USES TyConUniques 100-129
 903 -----------------------------------------------------
 904
 905 unitTyConKey = mkTupleTyConUnique Boxed 0
 906 \end{code}
 907
 908 %************************************************************************
 909 %*                                                                      *
 910 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 911 %*                                                                      *
 912 %************************************************************************
 913
 914 \begin{code}
 915 charDataConKey                          = mkPreludeDataConUnique  1
 916 consDataConKey                          = mkPreludeDataConUnique  2
 917 doubleDataConKey                        = mkPreludeDataConUnique  3
 918 falseDataConKey                         = mkPreludeDataConUnique  4
 919 floatDataConKey                         = mkPreludeDataConUnique  5
 920 intDataConKey                           = mkPreludeDataConUnique  6
 921 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 922 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 923 nilDataConKey                           = mkPreludeDataConUnique 11
 924 ratioDataConKey                         = mkPreludeDataConUnique 12
 925 stableNameDataConKey                    = mkPreludeDataConUnique 14
 926 trueDataConKey                          = mkPreludeDataConUnique 15
 927 wordDataConKey                          = mkPreludeDataConUnique 16
 928 ioDataConKey                            = mkPreludeDataConUnique 17
 929
 930 -- Generic data constructors
 931 crossDataConKey                         = mkPreludeDataConUnique 20
 932 inlDataConKey                           = mkPreludeDataConUnique 21
 933 inrDataConKey                           = mkPreludeDataConUnique 22
 934 genUnitDataConKey                       = mkPreludeDataConUnique 23
 935
 936 -- Data constructor for parallel arrays
 937 parrDataConKey                          = mkPreludeDataConUnique 24
 938
 939 leftDataConKey                          = mkPreludeDataConUnique 25
 940 rightDataConKey                         = mkPreludeDataConUnique 26
 941 \end{code}
 942
 943 %************************************************************************
 944 %*                                                                      *
 945 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 946 %*                                                                      *
 947 %************************************************************************
 948
 949 \begin{code}
 950 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 951 augmentIdKey                  = mkPreludeMiscIdUnique  3
 952 appendIdKey                   = mkPreludeMiscIdUnique  4
 953 buildIdKey                    = mkPreludeMiscIdUnique  5
 954 errorIdKey                    = mkPreludeMiscIdUnique  6
 955 foldlIdKey                    = mkPreludeMiscIdUnique  7
 956 foldrIdKey                    = mkPreludeMiscIdUnique  8
 957 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
 958 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
 959 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
 960 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
 961 integerZeroIdKey              = mkPreludeMiscIdUnique 13
 962 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
 963 seqIdKey                      = mkPreludeMiscIdUnique 15
 964 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 965 eqStringIdKey                 = mkPreludeMiscIdUnique 17
 966 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
 967 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
 968 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
 969 parErrorIdKey                 = mkPreludeMiscIdUnique 21
 970 parIdKey                      = mkPreludeMiscIdUnique 22
 971 patErrorIdKey                 = mkPreludeMiscIdUnique 23
 972 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
 973 recConErrorIdKey              = mkPreludeMiscIdUnique 25
 974 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
 975 traceIdKey                    = mkPreludeMiscIdUnique 27
 976 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
 977 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
 978 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
 979 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
 980
 981 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 982 concatIdKey                   = mkPreludeMiscIdUnique 33
 983 filterIdKey                   = mkPreludeMiscIdUnique 34
 984 zipIdKey                      = mkPreludeMiscIdUnique 35
 985 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 986 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 987 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 988 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 989 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 990 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 991 printIdKey                    = mkPreludeMiscIdUnique 43
 992 failIOIdKey                   = mkPreludeMiscIdUnique 44
 993 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
 994 voidArgIdKey                  = mkPreludeMiscIdUnique 47
 995 fstIdKey                      = mkPreludeMiscIdUnique 49
 996 sndIdKey                      = mkPreludeMiscIdUnique 50
 997 otherwiseIdKey                = mkPreludeMiscIdUnique 51
 998 assertIdKey                   = mkPreludeMiscIdUnique 53
 999 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1000
1001 rootMainKey                   = mkPreludeMiscIdUnique 55
1002 runMainKey                    = mkPreludeMiscIdUnique 56
1003
1004 andIdKey                      = mkPreludeMiscIdUnique 57
1005 orIdKey                       = mkPreludeMiscIdUnique 58
1006 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1007 lazyIdKey                     = mkPreludeMiscIdUnique 60
1008 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1009
1010 breakpointIdKey               = mkPreludeMiscIdUnique 62
1011 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1012 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1013 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1014 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1015 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1016
1017 inlineIdKey                   = mkPreludeMiscIdUnique 68
1018
1019 -- Parallel array functions
1020 nullPIdKey                    = mkPreludeMiscIdUnique 80
1021 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1022 replicatePIdKey               = mkPreludeMiscIdUnique 82
1023 mapPIdKey                     = mkPreludeMiscIdUnique 83
1024 filterPIdKey                  = mkPreludeMiscIdUnique 84
1025 zipPIdKey                     = mkPreludeMiscIdUnique 85
1026 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1027 indexPIdKey                   = mkPreludeMiscIdUnique 87
1028 toPIdKey                      = mkPreludeMiscIdUnique 88
1029 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1030 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1031 bpermutePIdKey                = mkPreludeMiscIdUnique 91
1032 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
1033 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
1034
1035 -- dotnet interop
1036 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1037 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1038 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1039 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1040 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1041
1042 \end{code}
1043
1044 Certain class operations from Prelude classes.  They get their own
1045 uniques so we can look them up easily when we want to conjure them up
1046 during type checking.
1047
1048 \begin{code}
1049         -- Just a place holder for  unbound variables  produced by the renamer:
1050 unboundKey                    = mkPreludeMiscIdUnique 101
1051
1052 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1053 minusClassOpKey               = mkPreludeMiscIdUnique 103
1054 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1055 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1056 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1057 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1058 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1059 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1060 geClassOpKey                  = mkPreludeMiscIdUnique 110
1061 negateClassOpKey              = mkPreludeMiscIdUnique 111
1062 failMClassOpKey               = mkPreludeMiscIdUnique 112
1063 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1064 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1065 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1066
1067 -- Recursive do notation
1068 mfixIdKey       = mkPreludeMiscIdUnique 118
1069
1070 -- Arrow notation
1071 arrAIdKey       = mkPreludeMiscIdUnique 119
1072 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1073 firstAIdKey     = mkPreludeMiscIdUnique 121
1074 appAIdKey       = mkPreludeMiscIdUnique 122
1075 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1076 loopAIdKey      = mkPreludeMiscIdUnique 124
1077
1078 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1079
1080 -- Flattened parallel array functions
1081 mkClosureIdKey                = mkPreludeMiscIdUnique 126
1082 applyClosureIdKey             = mkPreludeMiscIdUnique 127
1083 mkClosurePIdKey               = mkPreludeMiscIdUnique 128
1084 applyClosurePIdKey            = mkPreludeMiscIdUnique 129
1085 closurePAIdKey                = mkPreludeMiscIdUnique 130
1086 lengthPAIdKey                 = mkPreludeMiscIdUnique 131
1087 replicatePAIdKey              = mkPreludeMiscIdUnique 132
1088 emptyPAIdKey                  = mkPreludeMiscIdUnique 133
1089 packPAIdKey                   = mkPreludeMiscIdUnique 134
1090 combinePAIdKey                = mkPreludeMiscIdUnique 135
1091 intEqPAIdKey                  = mkPreludeMiscIdUnique 136
1092
1093 ---------------- Template Haskell -------------------
1094 --      USES IdUniques 200-399
1095 -----------------------------------------------------
1096 \end{code}
1097
1098
1099 %************************************************************************
1100 %*                                                                      *
1101 \subsection{Standard groups of types}
1102 %*                                                                      *
1103 %************************************************************************
1104
1105 \begin{code}
1106 numericTyKeys =
1107         [ wordTyConKey
1108         , intTyConKey
1109         , integerTyConKey
1110         , doubleTyConKey
1111         , floatTyConKey
1112         ]
1113 \end{code}
1114
1115
1116 %************************************************************************
1117 %*                                                                      *
1118 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1119 %*                                                                      *
1120 %************************************************************************
1121
1122 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1123 even though every numeric class has these two as a superclass,
1124 because the list of ambiguous dictionaries hasn't been simplified.
1125
1126 \begin{code}
1127 numericClassKeys =
1128         [ numClassKey
1129         , realClassKey
1130         , integralClassKey
1131         ]
1132         ++ fractionalClassKeys
1133
1134 fractionalClassKeys =
1135         [ fractionalClassKey
1136         , floatingClassKey
1137         , realFracClassKey
1138         , realFloatClassKey
1139         ]
1140
1141         -- the strictness analyser needs to know about numeric types
1142         -- (see SaAbsInt.lhs)
1143 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1144         [ readClassKey
1145         ]
1146
1147 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1148 -- and are: "classes defined in the Prelude or a standard library"
1149 standardClassKeys = derivableClassKeys ++ numericClassKeys
1150                   ++ [randomClassKey, randomGenClassKey,
1151                       functorClassKey,
1152                       monadClassKey, monadPlusClassKey,
1153                       isStringClassKey
1154                      ]
1155 \end{code}
1156
1157 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1158 (@TcDeriv@).
1159
1160 \begin{code}
1161 derivableClassKeys
1162   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1163       boundedClassKey, showClassKey, readClassKey ]
1164 \end{code}
1165