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, prTyConName
 221            , 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_REPR        = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Repr")
 280 nDP_UTILS       = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Utils")
 281 nDP_CLOSURE     = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Closure")
 282 nDP_INSTANCES   = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Instances")
 283
 284 mAIN            = mkMainModule_ mAIN_NAME
 285 rOOT_MAIN       = mkMainModule FSLIT(":Main") -- Root module for initialisation
 286
 287         -- The ':xxx' makes a module name that the user can never
 288         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 289         -- module name still starts with a capital letter, which keeps
 290         -- the z-encoded version consistent.
 291 iNTERACTIVE    = mkMainModule FSLIT(":Interactive")
 292 thFAKE         = mkMainModule FSLIT(":THFake")
 293
 294 pRELUDE_NAME   = mkModuleNameFS FSLIT("Prelude")
 295 mAIN_NAME      = mkModuleNameFS FSLIT("Main")
 296
 297 mkBaseModule :: FastString -> Module
 298 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
 299
 300 mkBaseModule_ :: ModuleName -> Module
 301 mkBaseModule_ m = mkModule basePackageId m
 302
 303 mkNDPModule :: FastString -> Module
 304 mkNDPModule m = mkModule ndpPackageId (mkModuleNameFS m)
 305
 306 mkNDPModule_ :: ModuleName -> Module
 307 mkNDPModule_ m = mkModule ndpPackageId m
 308
 309 mkMainModule :: FastString -> Module
 310 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
 311
 312 mkMainModule_ :: ModuleName -> Module
 313 mkMainModule_ m = mkModule mainPackageId m
 314 \end{code}
 315
 316 %************************************************************************
 317 %*                                                                      *
 318 \subsection{Constructing the names of tuples
 319 %*                                                                      *
 320 %************************************************************************
 321
 322 \begin{code}
 323 mkTupleModule :: Boxity -> Arity -> Module
 324 mkTupleModule Boxed   0 = gHC_BASE
 325 mkTupleModule Boxed   _ = dATA_TUP
 326 mkTupleModule Unboxed _ = gHC_PRIM
 327 \end{code}
 328
 329
 330 %************************************************************************
 331 %*                                                                      *
 332                         RdrNames
 333 %*                                                                      *
 334 %************************************************************************
 335
 336 \begin{code}
 337 main_RDR_Unqual         = mkUnqual varName FSLIT("main")
 338         -- We definitely don't want an Orig RdrName, because
 339         -- main might, in principle, be imported into module Main
 340
 341 eq_RDR                  = nameRdrName eqName
 342 ge_RDR                  = nameRdrName geName
 343 ne_RDR                  = varQual_RDR  gHC_BASE FSLIT("/=")
 344 le_RDR                  = varQual_RDR  gHC_BASE FSLIT("<=")
 345 gt_RDR                  = varQual_RDR  gHC_BASE FSLIT(">")
 346 compare_RDR             = varQual_RDR  gHC_BASE FSLIT("compare")
 347 ltTag_RDR               = dataQual_RDR gHC_BASE FSLIT("LT")
 348 eqTag_RDR               = dataQual_RDR gHC_BASE FSLIT("EQ")
 349 gtTag_RDR               = dataQual_RDR gHC_BASE FSLIT("GT")
 350
 351 eqClass_RDR             = nameRdrName eqClassName
 352 numClass_RDR            = nameRdrName numClassName
 353 ordClass_RDR            = nameRdrName ordClassName
 354 enumClass_RDR           = nameRdrName enumClassName
 355 monadClass_RDR          = nameRdrName monadClassName
 356
 357 map_RDR                 = varQual_RDR gHC_BASE FSLIT("map")
 358 append_RDR              = varQual_RDR gHC_BASE FSLIT("++")
 359
 360 foldr_RDR               = nameRdrName foldrName
 361 build_RDR               = nameRdrName buildName
 362 returnM_RDR             = nameRdrName returnMName
 363 bindM_RDR               = nameRdrName bindMName
 364 failM_RDR               = nameRdrName failMName
 365
 366 and_RDR                 = nameRdrName andName
 367
 368 left_RDR                = nameRdrName leftDataConName
 369 right_RDR               = nameRdrName rightDataConName
 370
 371 fromEnum_RDR            = varQual_RDR gHC_ENUM FSLIT("fromEnum")
 372 toEnum_RDR              = varQual_RDR gHC_ENUM FSLIT("toEnum")
 373
 374 enumFrom_RDR            = nameRdrName enumFromName
 375 enumFromTo_RDR          = nameRdrName enumFromToName
 376 enumFromThen_RDR        = nameRdrName enumFromThenName
 377 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 378
 379 ratioDataCon_RDR        = nameRdrName ratioDataConName
 380 plusInteger_RDR         = nameRdrName plusIntegerName
 381 timesInteger_RDR        = nameRdrName timesIntegerName
 382
 383 ioDataCon_RDR           = nameRdrName ioDataConName
 384
 385 eqString_RDR            = nameRdrName eqStringName
 386 unpackCString_RDR       = nameRdrName unpackCStringName
 387 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 388 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 389
 390 newStablePtr_RDR        = nameRdrName newStablePtrName
 391 wordDataCon_RDR         = dataQual_RDR gHC_WORD FSLIT("W#")
 392
 393 bindIO_RDR              = nameRdrName bindIOName
 394 returnIO_RDR            = nameRdrName returnIOName
 395
 396 fromInteger_RDR         = nameRdrName fromIntegerName
 397 fromRational_RDR        = nameRdrName fromRationalName
 398 minus_RDR               = nameRdrName minusName
 399 times_RDR               = varQual_RDR  gHC_NUM FSLIT("*")
 400 plus_RDR                = varQual_RDR gHC_NUM FSLIT("+")
 401
 402 fromString_RDR          = nameRdrName fromStringName
 403
 404 compose_RDR             = varQual_RDR gHC_BASE FSLIT(".")
 405
 406 not_RDR                 = varQual_RDR gHC_BASE FSLIT("not")
 407 getTag_RDR              = varQual_RDR gHC_BASE FSLIT("getTag")
 408 succ_RDR                = varQual_RDR gHC_ENUM FSLIT("succ")
 409 pred_RDR                = varQual_RDR gHC_ENUM FSLIT("pred")
 410 minBound_RDR            = varQual_RDR gHC_ENUM FSLIT("minBound")
 411 maxBound_RDR            = varQual_RDR gHC_ENUM FSLIT("maxBound")
 412 range_RDR               = varQual_RDR gHC_ARR FSLIT("range")
 413 inRange_RDR             = varQual_RDR gHC_ARR FSLIT("inRange")
 414 index_RDR               = varQual_RDR gHC_ARR FSLIT("index")
 415 unsafeIndex_RDR         = varQual_RDR gHC_ARR FSLIT("unsafeIndex")
 416 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR FSLIT("unsafeRangeSize")
 417
 418 readList_RDR            = varQual_RDR gHC_READ FSLIT("readList")
 419 readListDefault_RDR     = varQual_RDR gHC_READ FSLIT("readListDefault")
 420 readListPrec_RDR        = varQual_RDR gHC_READ FSLIT("readListPrec")
 421 readListPrecDefault_RDR = varQual_RDR gHC_READ FSLIT("readListPrecDefault")
 422 readPrec_RDR            = varQual_RDR gHC_READ FSLIT("readPrec")
 423 parens_RDR              = varQual_RDR gHC_READ FSLIT("parens")
 424 choose_RDR              = varQual_RDR gHC_READ FSLIT("choose")
 425 lexP_RDR                = varQual_RDR gHC_READ FSLIT("lexP")
 426
 427 punc_RDR                = dataQual_RDR lEX FSLIT("Punc")
 428 ident_RDR               = dataQual_RDR lEX FSLIT("Ident")
 429 symbol_RDR              = dataQual_RDR lEX FSLIT("Symbol")
 430
 431 step_RDR                = varQual_RDR  rEAD_PREC FSLIT("step")
 432 alt_RDR                 = varQual_RDR  rEAD_PREC FSLIT("+++")
 433 reset_RDR               = varQual_RDR  rEAD_PREC FSLIT("reset")
 434 prec_RDR                = varQual_RDR  rEAD_PREC FSLIT("prec")
 435
 436 showList_RDR            = varQual_RDR gHC_SHOW FSLIT("showList")
 437 showList___RDR          = varQual_RDR gHC_SHOW FSLIT("showList__")
 438 showsPrec_RDR           = varQual_RDR gHC_SHOW FSLIT("showsPrec")
 439 showString_RDR          = varQual_RDR gHC_SHOW FSLIT("showString")
 440 showSpace_RDR           = varQual_RDR gHC_SHOW FSLIT("showSpace")
 441 showParen_RDR           = varQual_RDR gHC_SHOW FSLIT("showParen")
 442
 443 typeOf_RDR     = varQual_RDR tYPEABLE FSLIT("typeOf")
 444 mkTypeRep_RDR  = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
 445 mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
 446
 447 undefined_RDR = varQual_RDR gHC_ERR FSLIT("undefined")
 448
 449 crossDataCon_RDR   = dataQual_RDR gHC_BASE FSLIT(":*:")
 450 inlDataCon_RDR     = dataQual_RDR gHC_BASE FSLIT("Inl")
 451 inrDataCon_RDR     = dataQual_RDR gHC_BASE FSLIT("Inr")
 452 genUnitDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Unit")
 453
 454 ----------------------
 455 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
 456 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
 457 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
 458 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
 459 \end{code}
 460
 461 %************************************************************************
 462 %*                                                                      *
 463 \subsection{Known-key names}
 464 %*                                                                      *
 465 %************************************************************************
 466
 467 Many of these Names are not really "built in", but some parts of the
 468 compiler (notably the deriving mechanism) need to mention their names,
 469 and it's convenient to write them all down in one place.
 470
 471 --MetaHaskell Extension  add the constrs and the lower case case
 472 -- guys as well (perhaps) e.g. see  trueDataConName     below
 473
 474
 475 \begin{code}
 476 runMainIOName = varQual gHC_TOP_HANDLER FSLIT("runMainIO") runMainKey
 477
 478 orderingTyConName = tcQual   gHC_BASE FSLIT("Ordering") orderingTyConKey
 479
 480 eitherTyConName   = tcQual  dATA_EITHER FSLIT("Either") eitherTyConKey
 481 leftDataConName   = conName dATA_EITHER FSLIT("Left")   leftDataConKey
 482 rightDataConName  = conName dATA_EITHER FSLIT("Right")  rightDataConKey
 483
 484 -- Generics
 485 crossTyConName     = tcQual   gHC_BASE FSLIT(":*:") crossTyConKey
 486 plusTyConName      = tcQual   gHC_BASE FSLIT(":+:") plusTyConKey
 487 genUnitTyConName   = tcQual   gHC_BASE FSLIT("Unit") genUnitTyConKey
 488
 489 -- Base strings Strings
 490 unpackCStringName       = varQual gHC_BASE FSLIT("unpackCString#") unpackCStringIdKey
 491 unpackCStringAppendName = varQual gHC_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey
 492 unpackCStringFoldrName  = varQual gHC_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
 493 unpackCStringUtf8Name   = varQual gHC_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
 494 eqStringName            = varQual gHC_BASE FSLIT("eqString")  eqStringIdKey
 495 stringTyConName         = tcQual  gHC_BASE FSLIT("String") stringTyConKey
 496
 497 -- The 'inline' function
 498 inlineIdName            = varQual gHC_BASE FSLIT("inline") inlineIdKey
 499
 500 -- Base classes (Eq, Ord, Functor)
 501 eqClassName       = clsQual  gHC_BASE FSLIT("Eq")      eqClassKey
 502 eqName            = methName gHC_BASE FSLIT("==")      eqClassOpKey
 503 ordClassName      = clsQual  gHC_BASE FSLIT("Ord")     ordClassKey
 504 geName            = methName gHC_BASE FSLIT(">=")      geClassOpKey
 505 functorClassName  = clsQual  gHC_BASE FSLIT("Functor") functorClassKey
 506
 507 -- Class Monad
 508 monadClassName     = clsQual  gHC_BASE FSLIT("Monad")  monadClassKey
 509 thenMName          = methName gHC_BASE FSLIT(">>")     thenMClassOpKey
 510 bindMName          = methName gHC_BASE FSLIT(">>=")    bindMClassOpKey
 511 returnMName        = methName gHC_BASE FSLIT("return") returnMClassOpKey
 512 failMName          = methName gHC_BASE FSLIT("fail")   failMClassOpKey
 513
 514 -- Random PrelBase functions
 515 fromStringName = methName dATA_STRING FSLIT("fromString") fromStringClassOpKey
 516 otherwiseIdName   = varQual gHC_BASE FSLIT("otherwise")  otherwiseIdKey
 517 foldrName         = varQual gHC_BASE FSLIT("foldr")      foldrIdKey
 518 buildName         = varQual gHC_BASE FSLIT("build")      buildIdKey
 519 augmentName       = varQual gHC_BASE FSLIT("augment")    augmentIdKey
 520 appendName        = varQual gHC_BASE FSLIT("++")         appendIdKey
 521 andName           = varQual gHC_BASE FSLIT("&&")         andIdKey
 522 orName            = varQual gHC_BASE FSLIT("||")         orIdKey
 523 assertName        = varQual gHC_BASE FSLIT("assert")     assertIdKey
 524 breakpointName    = varQual gHC_BASE FSLIT("breakpoint") breakpointIdKey
 525 breakpointCondName= varQual gHC_BASE FSLIT("breakpointCond") breakpointCondIdKey
 526 breakpointAutoName= varQual gHC_BASE FSLIT("breakpointAuto") breakpointAutoIdKey
 527 opaqueTyConName   = tcQual  gHC_BASE FSLIT("Opaque")   opaqueTyConKey
 528
 529 breakpointJumpName
 530     = mkInternalName
 531         breakpointJumpIdKey
 532         (mkOccNameFS varName FSLIT("breakpointJump"))
 533         noSrcSpan
 534 breakpointCondJumpName
 535     = mkInternalName
 536         breakpointCondJumpIdKey
 537         (mkOccNameFS varName FSLIT("breakpointCondJump"))
 538         noSrcSpan
 539 breakpointAutoJumpName
 540     = mkInternalName
 541         breakpointAutoJumpIdKey
 542         (mkOccNameFS varName FSLIT("breakpointAutoJump"))
 543         noSrcSpan
 544
 545 -- PrelTup
 546 fstName           = varQual dATA_TUP FSLIT("fst") fstIdKey
 547 sndName           = varQual dATA_TUP FSLIT("snd") sndIdKey
 548
 549 -- Module PrelNum
 550 numClassName      = clsQual  gHC_NUM FSLIT("Num") numClassKey
 551 fromIntegerName   = methName gHC_NUM FSLIT("fromInteger") fromIntegerClassOpKey
 552 minusName         = methName gHC_NUM FSLIT("-") minusClassOpKey
 553 negateName        = methName gHC_NUM FSLIT("negate") negateClassOpKey
 554 plusIntegerName   = varQual  gHC_NUM FSLIT("plusInteger") plusIntegerIdKey
 555 timesIntegerName  = varQual  gHC_NUM FSLIT("timesInteger") timesIntegerIdKey
 556 integerTyConName  = tcQual   gHC_NUM FSLIT("Integer") integerTyConKey
 557 smallIntegerDataConName = conName gHC_NUM FSLIT("S#") smallIntegerDataConKey
 558 largeIntegerDataConName = conName gHC_NUM FSLIT("J#") largeIntegerDataConKey
 559
 560 -- PrelReal types and classes
 561 rationalTyConName   = tcQual  gHC_REAL FSLIT("Rational") rationalTyConKey
 562 ratioTyConName      = tcQual  gHC_REAL FSLIT("Ratio") ratioTyConKey
 563 ratioDataConName    = conName gHC_REAL FSLIT(":%") ratioDataConKey
 564 realClassName       = clsQual gHC_REAL FSLIT("Real") realClassKey
 565 integralClassName   = clsQual gHC_REAL FSLIT("Integral") integralClassKey
 566 realFracClassName   = clsQual gHC_REAL FSLIT("RealFrac") realFracClassKey
 567 fractionalClassName = clsQual gHC_REAL FSLIT("Fractional") fractionalClassKey
 568 fromRationalName    = methName gHC_REAL  FSLIT("fromRational") fromRationalClassOpKey
 569
 570 -- PrelFloat classes
 571 floatingClassName  = clsQual  gHC_FLOAT FSLIT("Floating") floatingClassKey
 572 realFloatClassName = clsQual  gHC_FLOAT FSLIT("RealFloat") realFloatClassKey
 573
 574 -- Class Ix
 575 ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey
 576
 577 -- Class Typeable
 578 typeableClassName  = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey
 579 typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey
 580 typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey
 581 typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey
 582 typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey
 583 typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey
 584 typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey
 585 typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey
 586
 587 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 588                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 589                         , typeable6ClassName, typeable7ClassName ]
 590
 591 -- Class Data
 592 dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
 593
 594 -- Error module
 595 assertErrorName   = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey
 596
 597 -- Enum module (Enum, Bounded)
 598 enumClassName      = clsQual gHC_ENUM FSLIT("Enum") enumClassKey
 599 enumFromName       = methName gHC_ENUM FSLIT("enumFrom") enumFromClassOpKey
 600 enumFromToName     = methName gHC_ENUM FSLIT("enumFromTo") enumFromToClassOpKey
 601 enumFromThenName   = methName gHC_ENUM FSLIT("enumFromThen") enumFromThenClassOpKey
 602 enumFromThenToName = methName gHC_ENUM FSLIT("enumFromThenTo") enumFromThenToClassOpKey
 603 boundedClassName   = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey
 604
 605 -- List functions
 606 concatName        = varQual gHC_LIST FSLIT("concat") concatIdKey
 607 filterName        = varQual gHC_LIST FSLIT("filter") filterIdKey
 608 zipName           = varQual gHC_LIST FSLIT("zip") zipIdKey
 609
 610 -- Class Show
 611 showClassName     = clsQual gHC_SHOW FSLIT("Show")       showClassKey
 612
 613 -- Class Read
 614 readClassName      = clsQual gHC_READ FSLIT("Read") readClassKey
 615
 616 -- parallel array types and functions
 617 enumFromToPName    = varQual gHC_PARR FSLIT("enumFromToP") enumFromToPIdKey
 618 enumFromThenToPName= varQual gHC_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey
 619 nullPName         = varQual gHC_PARR FSLIT("nullP")              nullPIdKey
 620 lengthPName       = varQual gHC_PARR FSLIT("lengthP")            lengthPIdKey
 621 replicatePName    = varQual gHC_PARR FSLIT("replicateP")         replicatePIdKey
 622 mapPName          = varQual gHC_PARR FSLIT("mapP")               mapPIdKey
 623 filterPName       = varQual gHC_PARR FSLIT("filterP")            filterPIdKey
 624 zipPName          = varQual gHC_PARR FSLIT("zipP")               zipPIdKey
 625 crossMapPName     = varQual gHC_PARR FSLIT("crossMapP")          crossMapPIdKey
 626 indexPName        = varQual gHC_PARR FSLIT("!:")                 indexPIdKey
 627 toPName           = varQual gHC_PARR FSLIT("toP")                toPIdKey
 628 bpermutePName     = varQual gHC_PARR FSLIT("bpermuteP")    bpermutePIdKey
 629 bpermuteDftPName  = varQual gHC_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey
 630 indexOfPName      = varQual gHC_PARR FSLIT("indexOfP")     indexOfPIdKey
 631
 632 -- IOBase things
 633 ioTyConName       = tcQual  gHC_IO_BASE FSLIT("IO") ioTyConKey
 634 ioDataConName     = conName gHC_IO_BASE FSLIT("IO") ioDataConKey
 635 thenIOName        = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey
 636 bindIOName        = varQual gHC_IO_BASE FSLIT("bindIO") bindIOIdKey
 637 returnIOName      = varQual gHC_IO_BASE FSLIT("returnIO") returnIOIdKey
 638 failIOName        = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey
 639
 640 -- IO things
 641 printName         = varQual sYSTEM_IO FSLIT("print") printIdKey
 642
 643 -- Int, Word, and Addr things
 644 int8TyConName     = tcQual gHC_INT  FSLIT("Int8") int8TyConKey
 645 int16TyConName    = tcQual gHC_INT  FSLIT("Int16") int16TyConKey
 646 int32TyConName    = tcQual gHC_INT  FSLIT("Int32") int32TyConKey
 647 int64TyConName    = tcQual gHC_INT  FSLIT("Int64") int64TyConKey
 648
 649 -- Word module
 650 word8TyConName    = tcQual  gHC_WORD FSLIT("Word8")  word8TyConKey
 651 word16TyConName   = tcQual  gHC_WORD FSLIT("Word16") word16TyConKey
 652 word32TyConName   = tcQual  gHC_WORD FSLIT("Word32") word32TyConKey
 653 word64TyConName   = tcQual  gHC_WORD FSLIT("Word64") word64TyConKey
 654 wordTyConName     = tcQual  gHC_WORD FSLIT("Word")   wordTyConKey
 655 wordDataConName   = conName gHC_WORD FSLIT("W#") wordDataConKey
 656
 657 -- PrelPtr module
 658 ptrTyConName      = tcQual   gHC_PTR FSLIT("Ptr") ptrTyConKey
 659 funPtrTyConName   = tcQual   gHC_PTR FSLIT("FunPtr") funPtrTyConKey
 660
 661 -- Foreign objects and weak pointers
 662 stablePtrTyConName    = tcQual   gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey
 663 newStablePtrName      = varQual  gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey
 664
 665 -- PrelST module
 666 runSTRepName       = varQual gHC_ST  FSLIT("runSTRep") runSTRepIdKey
 667
 668 -- Recursive-do notation
 669 monadFixClassName  = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
 670 mfixName           = methName mONAD_FIX FSLIT("mfix") mfixIdKey
 671
 672 -- Arrow notation
 673 arrAName           = varQual aRROW FSLIT("arr")   arrAIdKey
 674 composeAName       = varQual aRROW FSLIT(">>>")   composeAIdKey
 675 firstAName         = varQual aRROW FSLIT("first") firstAIdKey
 676 appAName           = varQual aRROW FSLIT("app")   appAIdKey
 677 choiceAName        = varQual aRROW FSLIT("|||")   choiceAIdKey
 678 loopAName          = varQual aRROW FSLIT("loop")  loopAIdKey
 679
 680 -- Other classes, needed for type defaulting
 681 monadPlusClassName  = clsQual mONAD FSLIT("MonadPlus")  monadPlusClassKey
 682 randomClassName     = clsQual rANDOM FSLIT("Random")    randomClassKey
 683 randomGenClassName  = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey
 684 isStringClassName   = clsQual dATA_STRING FSLIT("IsString") isStringClassKey
 685
 686 -- dotnet interop
 687 objectTyConName     = tcQual   dOTNET FSLIT("Object") objectTyConKey
 688         -- objectTyConName was "wTcQual", but that's gone now, and
 689         -- I can't see why it was wired in anyway...
 690 unmarshalObjectName = varQual  dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey
 691 marshalObjectName   = varQual  dOTNET FSLIT("marshalObject") marshalObjectIdKey
 692 marshalStringName   = varQual  dOTNET FSLIT("marshalString") marshalStringIdKey
 693 unmarshalStringName = varQual  dOTNET FSLIT("unmarshalString") unmarshalStringIdKey
 694 checkDotnetResName  = varQual  dOTNET FSLIT("checkResult")     checkDotnetResNameIdKey
 695
 696 -- NDP stuff
 697 parrayTyConName     = tcQual   nDP_PARRAY FSLIT("PArray") parrayTyConKey
 698 paTyConName         = tcQual   nDP_PARRAY FSLIT("PA")     paTyConKey
 699 preprTyConName      = tcQual   nDP_PARRAY FSLIT("PRepr")  preprTyConKey
 700 prTyConName         = clsQual  nDP_PARRAY FSLIT("PR")     prTyConKey
 701 embedTyConName      = tcQual   nDP_REPR   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 prTyConKey                              = mkPreludeTyConUnique 140
 898
 899
 900 ---------------- Template Haskell -------------------
 901 --      USES TyConUniques 100-129
 902 -----------------------------------------------------
 903
 904 unitTyConKey = mkTupleTyConUnique Boxed 0
 905 \end{code}
 906
 907 %************************************************************************
 908 %*                                                                      *
 909 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 910 %*                                                                      *
 911 %************************************************************************
 912
 913 \begin{code}
 914 charDataConKey                          = mkPreludeDataConUnique  1
 915 consDataConKey                          = mkPreludeDataConUnique  2
 916 doubleDataConKey                        = mkPreludeDataConUnique  3
 917 falseDataConKey                         = mkPreludeDataConUnique  4
 918 floatDataConKey                         = mkPreludeDataConUnique  5
 919 intDataConKey                           = mkPreludeDataConUnique  6
 920 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 921 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 922 nilDataConKey                           = mkPreludeDataConUnique 11
 923 ratioDataConKey                         = mkPreludeDataConUnique 12
 924 stableNameDataConKey                    = mkPreludeDataConUnique 14
 925 trueDataConKey                          = mkPreludeDataConUnique 15
 926 wordDataConKey                          = mkPreludeDataConUnique 16
 927 ioDataConKey                            = mkPreludeDataConUnique 17
 928
 929 -- Generic data constructors
 930 crossDataConKey                         = mkPreludeDataConUnique 20
 931 inlDataConKey                           = mkPreludeDataConUnique 21
 932 inrDataConKey                           = mkPreludeDataConUnique 22
 933 genUnitDataConKey                       = mkPreludeDataConUnique 23
 934
 935 -- Data constructor for parallel arrays
 936 parrDataConKey                          = mkPreludeDataConUnique 24
 937
 938 leftDataConKey                          = mkPreludeDataConUnique 25
 939 rightDataConKey                         = mkPreludeDataConUnique 26
 940 \end{code}
 941
 942 %************************************************************************
 943 %*                                                                      *
 944 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 945 %*                                                                      *
 946 %************************************************************************
 947
 948 \begin{code}
 949 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 950 augmentIdKey                  = mkPreludeMiscIdUnique  3
 951 appendIdKey                   = mkPreludeMiscIdUnique  4
 952 buildIdKey                    = mkPreludeMiscIdUnique  5
 953 errorIdKey                    = mkPreludeMiscIdUnique  6
 954 foldlIdKey                    = mkPreludeMiscIdUnique  7
 955 foldrIdKey                    = mkPreludeMiscIdUnique  8
 956 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
 957 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
 958 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
 959 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
 960 integerZeroIdKey              = mkPreludeMiscIdUnique 13
 961 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
 962 seqIdKey                      = mkPreludeMiscIdUnique 15
 963 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 964 eqStringIdKey                 = mkPreludeMiscIdUnique 17
 965 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
 966 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
 967 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
 968 parErrorIdKey                 = mkPreludeMiscIdUnique 21
 969 parIdKey                      = mkPreludeMiscIdUnique 22
 970 patErrorIdKey                 = mkPreludeMiscIdUnique 23
 971 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
 972 recConErrorIdKey              = mkPreludeMiscIdUnique 25
 973 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
 974 traceIdKey                    = mkPreludeMiscIdUnique 27
 975 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
 976 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
 977 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
 978 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
 979
 980 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 981 concatIdKey                   = mkPreludeMiscIdUnique 33
 982 filterIdKey                   = mkPreludeMiscIdUnique 34
 983 zipIdKey                      = mkPreludeMiscIdUnique 35
 984 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 985 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 986 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 987 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 988 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 989 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 990 printIdKey                    = mkPreludeMiscIdUnique 43
 991 failIOIdKey                   = mkPreludeMiscIdUnique 44
 992 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
 993 voidArgIdKey                  = mkPreludeMiscIdUnique 47
 994 fstIdKey                      = mkPreludeMiscIdUnique 49
 995 sndIdKey                      = mkPreludeMiscIdUnique 50
 996 otherwiseIdKey                = mkPreludeMiscIdUnique 51
 997 assertIdKey                   = mkPreludeMiscIdUnique 53
 998 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
 999
1000 rootMainKey                   = mkPreludeMiscIdUnique 55
1001 runMainKey                    = mkPreludeMiscIdUnique 56
1002
1003 andIdKey                      = mkPreludeMiscIdUnique 57
1004 orIdKey                       = mkPreludeMiscIdUnique 58
1005 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1006 lazyIdKey                     = mkPreludeMiscIdUnique 60
1007 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1008
1009 breakpointIdKey               = mkPreludeMiscIdUnique 62
1010 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1011 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1012 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1013 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1014 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1015
1016 inlineIdKey                   = mkPreludeMiscIdUnique 68
1017
1018 -- Parallel array functions
1019 nullPIdKey                    = mkPreludeMiscIdUnique 80
1020 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1021 replicatePIdKey               = mkPreludeMiscIdUnique 82
1022 mapPIdKey                     = mkPreludeMiscIdUnique 83
1023 filterPIdKey                  = mkPreludeMiscIdUnique 84
1024 zipPIdKey                     = mkPreludeMiscIdUnique 85
1025 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1026 indexPIdKey                   = mkPreludeMiscIdUnique 87
1027 toPIdKey                      = mkPreludeMiscIdUnique 88
1028 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1029 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1030 bpermutePIdKey                = mkPreludeMiscIdUnique 91
1031 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
1032 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
1033
1034 -- dotnet interop
1035 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1036 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1037 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1038 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1039 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1040
1041 \end{code}
1042
1043 Certain class operations from Prelude classes.  They get their own
1044 uniques so we can look them up easily when we want to conjure them up
1045 during type checking.
1046
1047 \begin{code}
1048         -- Just a place holder for  unbound variables  produced by the renamer:
1049 unboundKey                    = mkPreludeMiscIdUnique 101
1050
1051 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1052 minusClassOpKey               = mkPreludeMiscIdUnique 103
1053 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1054 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1055 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1056 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1057 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1058 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1059 geClassOpKey                  = mkPreludeMiscIdUnique 110
1060 negateClassOpKey              = mkPreludeMiscIdUnique 111
1061 failMClassOpKey               = mkPreludeMiscIdUnique 112
1062 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1063 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1064 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1065
1066 -- Recursive do notation
1067 mfixIdKey       = mkPreludeMiscIdUnique 118
1068
1069 -- Arrow notation
1070 arrAIdKey       = mkPreludeMiscIdUnique 119
1071 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1072 firstAIdKey     = mkPreludeMiscIdUnique 121
1073 appAIdKey       = mkPreludeMiscIdUnique 122
1074 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1075 loopAIdKey      = mkPreludeMiscIdUnique 124
1076
1077 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1078
1079 -- Flattened parallel array functions
1080 mkClosureIdKey                = mkPreludeMiscIdUnique 126
1081 applyClosureIdKey             = mkPreludeMiscIdUnique 127
1082 mkClosurePIdKey               = mkPreludeMiscIdUnique 128
1083 applyClosurePIdKey            = mkPreludeMiscIdUnique 129
1084 closurePAIdKey                = mkPreludeMiscIdUnique 130
1085 lengthPAIdKey                 = mkPreludeMiscIdUnique 131
1086 replicatePAIdKey              = mkPreludeMiscIdUnique 132
1087 emptyPAIdKey                  = mkPreludeMiscIdUnique 133
1088 packPAIdKey                   = mkPreludeMiscIdUnique 134
1089 combinePAIdKey                = mkPreludeMiscIdUnique 135
1090 intEqPAIdKey                  = mkPreludeMiscIdUnique 136
1091
1092 ---------------- Template Haskell -------------------
1093 --      USES IdUniques 200-399
1094 -----------------------------------------------------
1095 \end{code}
1096
1097
1098 %************************************************************************
1099 %*                                                                      *
1100 \subsection{Standard groups of types}
1101 %*                                                                      *
1102 %************************************************************************
1103
1104 \begin{code}
1105 numericTyKeys =
1106         [ wordTyConKey
1107         , intTyConKey
1108         , integerTyConKey
1109         , doubleTyConKey
1110         , floatTyConKey
1111         ]
1112 \end{code}
1113
1114
1115 %************************************************************************
1116 %*                                                                      *
1117 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1118 %*                                                                      *
1119 %************************************************************************
1120
1121 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1122 even though every numeric class has these two as a superclass,
1123 because the list of ambiguous dictionaries hasn't been simplified.
1124
1125 \begin{code}
1126 numericClassKeys =
1127         [ numClassKey
1128         , realClassKey
1129         , integralClassKey
1130         ]
1131         ++ fractionalClassKeys
1132
1133 fractionalClassKeys =
1134         [ fractionalClassKey
1135         , floatingClassKey
1136         , realFracClassKey
1137         , realFloatClassKey
1138         ]
1139
1140         -- the strictness analyser needs to know about numeric types
1141         -- (see SaAbsInt.lhs)
1142 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1143         [ readClassKey
1144         ]
1145
1146 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1147 -- and are: "classes defined in the Prelude or a standard library"
1148 standardClassKeys = derivableClassKeys ++ numericClassKeys
1149                   ++ [randomClassKey, randomGenClassKey,
1150                       functorClassKey,
1151                       monadClassKey, monadPlusClassKey,
1152                       isStringClassKey
1153                      ]
1154 \end{code}
1155
1156 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1157 (@TcDeriv@).
1158
1159 \begin{code}
1160 derivableClassKeys
1161   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1162       boundedClassKey, showClassKey, readClassKey ]
1163 \end{code}
1164