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, prClassName
 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 prClassName         = clsQual  nDP_PARRAY FSLIT("PR")     prClassKey
 700 ndpCrossTyConName   = tcQual   nDP_PARRAY FSLIT(":*:")    ndpCrossTyConKey
 701 ndpPlusTyConName    = tcQual   nDP_PARRAY FSLIT(":+:")    ndpPlusTyConKey
 702 embedTyConName      = tcQual   nDP_PARRAY FSLIT("Embed")  embedTyConKey
 703 lengthPAName        = varQual  nDP_PARRAY FSLIT("lengthPA")    lengthPAIdKey
 704 replicatePAName     = varQual  nDP_PARRAY FSLIT("replicatePA") replicatePAIdKey
 705 emptyPAName         = varQual  nDP_PARRAY FSLIT("emptyPA") emptyPAIdKey
 706 packPAName          = varQual  nDP_PARRAY FSLIT("packPA")  packPAIdKey
 707 combinePAName       = varQual  nDP_PARRAY FSLIT("combinePA") combinePAIdKey
 708 intEqPAName         = varQual  nDP_UTILS  FSLIT("intEqPA") intEqPAIdKey
 709 closureTyConName    = tcQual   nDP_CLOSURE FSLIT(":->")    closureTyConKey
 710 mkClosureName       = varQual  nDP_CLOSURE FSLIT("mkClosure")  mkClosureIdKey
 711 applyClosureName    = varQual  nDP_CLOSURE FSLIT("$:")         applyClosureIdKey
 712 mkClosurePName      = varQual  nDP_CLOSURE FSLIT("mkClosureP") mkClosurePIdKey
 713 applyClosurePName   = varQual  nDP_CLOSURE FSLIT("$:^")        applyClosurePIdKey
 714 \end{code}
 715
 716 %************************************************************************
 717 %*                                                                      *
 718 \subsection{Local helpers}
 719 %*                                                                      *
 720 %************************************************************************
 721
 722 All these are original names; hence mkOrig
 723
 724 \begin{code}
 725 varQual  = mk_known_key_name varName
 726 tcQual   = mk_known_key_name tcName
 727 clsQual  = mk_known_key_name clsName
 728
 729 mk_known_key_name space mod str uniq
 730   = mkExternalName uniq mod (mkOccNameFS space str) noSrcSpan
 731
 732 conName :: Module -> FastString -> Unique -> Name
 733 conName mod occ uniq
 734   = mkExternalName uniq mod (mkOccNameFS dataName occ) noSrcSpan
 735
 736 methName :: Module -> FastString -> Unique -> Name
 737 methName mod occ uniq
 738   = mkExternalName uniq mod (mkVarOccFS occ) noSrcSpan
 739 \end{code}
 740
 741 %************************************************************************
 742 %*                                                                      *
 743 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 744 %*                                                                      *
 745 %************************************************************************
 746 --MetaHaskell extension hand allocate keys here
 747
 748 \begin{code}
 749 boundedClassKey         = mkPreludeClassUnique 1
 750 enumClassKey            = mkPreludeClassUnique 2
 751 eqClassKey              = mkPreludeClassUnique 3
 752 floatingClassKey        = mkPreludeClassUnique 5
 753 fractionalClassKey      = mkPreludeClassUnique 6
 754 integralClassKey        = mkPreludeClassUnique 7
 755 monadClassKey           = mkPreludeClassUnique 8
 756 dataClassKey            = mkPreludeClassUnique 9
 757 functorClassKey         = mkPreludeClassUnique 10
 758 numClassKey             = mkPreludeClassUnique 11
 759 ordClassKey             = mkPreludeClassUnique 12
 760 readClassKey            = mkPreludeClassUnique 13
 761 realClassKey            = mkPreludeClassUnique 14
 762 realFloatClassKey       = mkPreludeClassUnique 15
 763 realFracClassKey        = mkPreludeClassUnique 16
 764 showClassKey            = mkPreludeClassUnique 17
 765 ixClassKey              = mkPreludeClassUnique 18
 766
 767 typeableClassKey        = mkPreludeClassUnique 20
 768 typeable1ClassKey       = mkPreludeClassUnique 21
 769 typeable2ClassKey       = mkPreludeClassUnique 22
 770 typeable3ClassKey       = mkPreludeClassUnique 23
 771 typeable4ClassKey       = mkPreludeClassUnique 24
 772 typeable5ClassKey       = mkPreludeClassUnique 25
 773 typeable6ClassKey       = mkPreludeClassUnique 26
 774 typeable7ClassKey       = mkPreludeClassUnique 27
 775
 776 monadFixClassKey        = mkPreludeClassUnique 28
 777
 778 monadPlusClassKey       = mkPreludeClassUnique 30
 779 randomClassKey          = mkPreludeClassUnique 31
 780 randomGenClassKey       = mkPreludeClassUnique 32
 781
 782 isStringClassKey        = mkPreludeClassUnique 33
 783
 784 prClassKey              = mkPreludeClassUnique 34
 785 \end{code}
 786
 787 %************************************************************************
 788 %*                                                                      *
 789 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 790 %*                                                                      *
 791 %************************************************************************
 792
 793 \begin{code}
 794 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 795 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 796 boolTyConKey                            = mkPreludeTyConUnique  4
 797 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 798 charPrimTyConKey                        = mkPreludeTyConUnique  7
 799 charTyConKey                            = mkPreludeTyConUnique  8
 800 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 801 doubleTyConKey                          = mkPreludeTyConUnique 10
 802 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 803 floatTyConKey                           = mkPreludeTyConUnique 12
 804 funTyConKey                             = mkPreludeTyConUnique 13
 805 intPrimTyConKey                         = mkPreludeTyConUnique 14
 806 intTyConKey                             = mkPreludeTyConUnique 15
 807 int8TyConKey                            = mkPreludeTyConUnique 16
 808 int16TyConKey                           = mkPreludeTyConUnique 17
 809 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 810 int32TyConKey                           = mkPreludeTyConUnique 19
 811 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 812 int64TyConKey                           = mkPreludeTyConUnique 21
 813 integerTyConKey                         = mkPreludeTyConUnique 22
 814 listTyConKey                            = mkPreludeTyConUnique 23
 815 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 816 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 817 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 818 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 819 orderingTyConKey                        = mkPreludeTyConUnique 30
 820 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 821 ratioTyConKey                           = mkPreludeTyConUnique 32
 822 rationalTyConKey                        = mkPreludeTyConUnique 33
 823 realWorldTyConKey                       = mkPreludeTyConUnique 34
 824 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 825 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 826
 827 anyPrimTyConKey                         = mkPreludeTyConUnique 37
 828 anyPrimTyCon1Key                        = mkPreludeTyConUnique 38
 829
 830 statePrimTyConKey                       = mkPreludeTyConUnique 50
 831 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 832 stableNameTyConKey                      = mkPreludeTyConUnique 52
 833 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 834 ioTyConKey                              = mkPreludeTyConUnique 56
 835 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 836 wordTyConKey                            = mkPreludeTyConUnique 59
 837 word8TyConKey                           = mkPreludeTyConUnique 60
 838 word16TyConKey                          = mkPreludeTyConUnique 61
 839 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 840 word32TyConKey                          = mkPreludeTyConUnique 63
 841 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 842 word64TyConKey                          = mkPreludeTyConUnique 65
 843 liftedConKey                            = mkPreludeTyConUnique 66
 844 unliftedConKey                          = mkPreludeTyConUnique 67
 845 anyBoxConKey                            = mkPreludeTyConUnique 68
 846 kindConKey                              = mkPreludeTyConUnique 69
 847 boxityConKey                            = mkPreludeTyConUnique 70
 848 typeConKey                              = mkPreludeTyConUnique 71
 849 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 850 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 851 ptrTyConKey                             = mkPreludeTyConUnique 74
 852 funPtrTyConKey                          = mkPreludeTyConUnique 75
 853 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
 854
 855 -- Generic Type Constructors
 856 crossTyConKey                           = mkPreludeTyConUnique 79
 857 plusTyConKey                            = mkPreludeTyConUnique 80
 858 genUnitTyConKey                         = mkPreludeTyConUnique 81
 859
 860 -- Parallel array type constructor
 861 parrTyConKey                            = mkPreludeTyConUnique 82
 862
 863 -- dotnet interop
 864 objectTyConKey                          = mkPreludeTyConUnique 83
 865
 866 eitherTyConKey                          = mkPreludeTyConUnique 84
 867
 868 -- Super Kinds constructors
 869 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
 870 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
 871
 872 -- Kind constructors
 873 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
 874 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
 875 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
 876 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
 877 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
 878
 879 -- Coercion constructors
 880 symCoercionTyConKey                     = mkPreludeTyConUnique 93
 881 transCoercionTyConKey                   = mkPreludeTyConUnique 94
 882 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
 883 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
 884 instCoercionTyConKey                    = mkPreludeTyConUnique 97
 885 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
 886
 887 unknownTyConKey                         = mkPreludeTyConUnique 99
 888 unknown1TyConKey                        = mkPreludeTyConUnique 130
 889 unknown2TyConKey                        = mkPreludeTyConUnique 131
 890 unknown3TyConKey                        = mkPreludeTyConUnique 132
 891 opaqueTyConKey                          = mkPreludeTyConUnique 133
 892
 893 stringTyConKey                          = mkPreludeTyConUnique 134
 894
 895 parrayTyConKey                          = mkPreludeTyConUnique 135
 896 closureTyConKey                         = mkPreludeTyConUnique 136
 897 paTyConKey                              = mkPreludeTyConUnique 137
 898 preprTyConKey                           = mkPreludeTyConUnique 138
 899 embedTyConKey                           = mkPreludeTyConUnique 139
 900 ndpCrossTyConKey                        = mkPreludeTyConUnique 140
 901 ndpPlusTyConKey                         = mkPreludeTyConUnique 141
 902
 903
 904 ---------------- Template Haskell -------------------
 905 --      USES TyConUniques 100-129
 906 -----------------------------------------------------
 907
 908 unitTyConKey = mkTupleTyConUnique Boxed 0
 909 \end{code}
 910
 911 %************************************************************************
 912 %*                                                                      *
 913 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 914 %*                                                                      *
 915 %************************************************************************
 916
 917 \begin{code}
 918 charDataConKey                          = mkPreludeDataConUnique  1
 919 consDataConKey                          = mkPreludeDataConUnique  2
 920 doubleDataConKey                        = mkPreludeDataConUnique  3
 921 falseDataConKey                         = mkPreludeDataConUnique  4
 922 floatDataConKey                         = mkPreludeDataConUnique  5
 923 intDataConKey                           = mkPreludeDataConUnique  6
 924 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 925 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 926 nilDataConKey                           = mkPreludeDataConUnique 11
 927 ratioDataConKey                         = mkPreludeDataConUnique 12
 928 stableNameDataConKey                    = mkPreludeDataConUnique 14
 929 trueDataConKey                          = mkPreludeDataConUnique 15
 930 wordDataConKey                          = mkPreludeDataConUnique 16
 931 ioDataConKey                            = mkPreludeDataConUnique 17
 932
 933 -- Generic data constructors
 934 crossDataConKey                         = mkPreludeDataConUnique 20
 935 inlDataConKey                           = mkPreludeDataConUnique 21
 936 inrDataConKey                           = mkPreludeDataConUnique 22
 937 genUnitDataConKey                       = mkPreludeDataConUnique 23
 938
 939 -- Data constructor for parallel arrays
 940 parrDataConKey                          = mkPreludeDataConUnique 24
 941
 942 leftDataConKey                          = mkPreludeDataConUnique 25
 943 rightDataConKey                         = mkPreludeDataConUnique 26
 944 \end{code}
 945
 946 %************************************************************************
 947 %*                                                                      *
 948 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 949 %*                                                                      *
 950 %************************************************************************
 951
 952 \begin{code}
 953 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 954 augmentIdKey                  = mkPreludeMiscIdUnique  3
 955 appendIdKey                   = mkPreludeMiscIdUnique  4
 956 buildIdKey                    = mkPreludeMiscIdUnique  5
 957 errorIdKey                    = mkPreludeMiscIdUnique  6
 958 foldlIdKey                    = mkPreludeMiscIdUnique  7
 959 foldrIdKey                    = mkPreludeMiscIdUnique  8
 960 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
 961 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
 962 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
 963 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
 964 integerZeroIdKey              = mkPreludeMiscIdUnique 13
 965 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
 966 seqIdKey                      = mkPreludeMiscIdUnique 15
 967 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 968 eqStringIdKey                 = mkPreludeMiscIdUnique 17
 969 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
 970 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
 971 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
 972 parErrorIdKey                 = mkPreludeMiscIdUnique 21
 973 parIdKey                      = mkPreludeMiscIdUnique 22
 974 patErrorIdKey                 = mkPreludeMiscIdUnique 23
 975 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
 976 recConErrorIdKey              = mkPreludeMiscIdUnique 25
 977 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
 978 traceIdKey                    = mkPreludeMiscIdUnique 27
 979 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
 980 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
 981 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
 982 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
 983
 984 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 985 concatIdKey                   = mkPreludeMiscIdUnique 33
 986 filterIdKey                   = mkPreludeMiscIdUnique 34
 987 zipIdKey                      = mkPreludeMiscIdUnique 35
 988 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 989 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 990 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 991 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 992 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 993 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 994 printIdKey                    = mkPreludeMiscIdUnique 43
 995 failIOIdKey                   = mkPreludeMiscIdUnique 44
 996 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
 997 voidArgIdKey                  = mkPreludeMiscIdUnique 47
 998 fstIdKey                      = mkPreludeMiscIdUnique 49
 999 sndIdKey                      = mkPreludeMiscIdUnique 50
1000 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1001 assertIdKey                   = mkPreludeMiscIdUnique 53
1002 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1003
1004 rootMainKey                   = mkPreludeMiscIdUnique 55
1005 runMainKey                    = mkPreludeMiscIdUnique 56
1006
1007 andIdKey                      = mkPreludeMiscIdUnique 57
1008 orIdKey                       = mkPreludeMiscIdUnique 58
1009 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1010 lazyIdKey                     = mkPreludeMiscIdUnique 60
1011 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1012
1013 breakpointIdKey               = mkPreludeMiscIdUnique 62
1014 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1015 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1016 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1017 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1018 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1019
1020 inlineIdKey                   = mkPreludeMiscIdUnique 68
1021
1022 -- Parallel array functions
1023 nullPIdKey                    = mkPreludeMiscIdUnique 80
1024 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1025 replicatePIdKey               = mkPreludeMiscIdUnique 82
1026 mapPIdKey                     = mkPreludeMiscIdUnique 83
1027 filterPIdKey                  = mkPreludeMiscIdUnique 84
1028 zipPIdKey                     = mkPreludeMiscIdUnique 85
1029 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1030 indexPIdKey                   = mkPreludeMiscIdUnique 87
1031 toPIdKey                      = mkPreludeMiscIdUnique 88
1032 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1033 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1034 bpermutePIdKey                = mkPreludeMiscIdUnique 91
1035 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
1036 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
1037
1038 -- dotnet interop
1039 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1040 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1041 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1042 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1043 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1044
1045 \end{code}
1046
1047 Certain class operations from Prelude classes.  They get their own
1048 uniques so we can look them up easily when we want to conjure them up
1049 during type checking.
1050
1051 \begin{code}
1052         -- Just a place holder for  unbound variables  produced by the renamer:
1053 unboundKey                    = mkPreludeMiscIdUnique 101
1054
1055 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1056 minusClassOpKey               = mkPreludeMiscIdUnique 103
1057 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1058 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1059 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1060 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1061 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1062 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1063 geClassOpKey                  = mkPreludeMiscIdUnique 110
1064 negateClassOpKey              = mkPreludeMiscIdUnique 111
1065 failMClassOpKey               = mkPreludeMiscIdUnique 112
1066 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1067 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1068 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1069
1070 -- Recursive do notation
1071 mfixIdKey       = mkPreludeMiscIdUnique 118
1072
1073 -- Arrow notation
1074 arrAIdKey       = mkPreludeMiscIdUnique 119
1075 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1076 firstAIdKey     = mkPreludeMiscIdUnique 121
1077 appAIdKey       = mkPreludeMiscIdUnique 122
1078 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1079 loopAIdKey      = mkPreludeMiscIdUnique 124
1080
1081 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1082
1083 -- Flattened parallel array functions
1084 mkClosureIdKey                = mkPreludeMiscIdUnique 126
1085 applyClosureIdKey             = mkPreludeMiscIdUnique 127
1086 mkClosurePIdKey               = mkPreludeMiscIdUnique 128
1087 applyClosurePIdKey            = mkPreludeMiscIdUnique 129
1088 closurePAIdKey                = mkPreludeMiscIdUnique 130
1089 lengthPAIdKey                 = mkPreludeMiscIdUnique 131
1090 replicatePAIdKey              = mkPreludeMiscIdUnique 132
1091 emptyPAIdKey                  = mkPreludeMiscIdUnique 133
1092 packPAIdKey                   = mkPreludeMiscIdUnique 134
1093 combinePAIdKey                = mkPreludeMiscIdUnique 135
1094 intEqPAIdKey                  = mkPreludeMiscIdUnique 136
1095
1096 ---------------- Template Haskell -------------------
1097 --      USES IdUniques 200-399
1098 -----------------------------------------------------
1099 \end{code}
1100
1101
1102 %************************************************************************
1103 %*                                                                      *
1104 \subsection{Standard groups of types}
1105 %*                                                                      *
1106 %************************************************************************
1107
1108 \begin{code}
1109 numericTyKeys =
1110         [ wordTyConKey
1111         , intTyConKey
1112         , integerTyConKey
1113         , doubleTyConKey
1114         , floatTyConKey
1115         ]
1116 \end{code}
1117
1118
1119 %************************************************************************
1120 %*                                                                      *
1121 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1122 %*                                                                      *
1123 %************************************************************************
1124
1125 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1126 even though every numeric class has these two as a superclass,
1127 because the list of ambiguous dictionaries hasn't been simplified.
1128
1129 \begin{code}
1130 numericClassKeys =
1131         [ numClassKey
1132         , realClassKey
1133         , integralClassKey
1134         ]
1135         ++ fractionalClassKeys
1136
1137 fractionalClassKeys =
1138         [ fractionalClassKey
1139         , floatingClassKey
1140         , realFracClassKey
1141         , realFloatClassKey
1142         ]
1143
1144         -- the strictness analyser needs to know about numeric types
1145         -- (see SaAbsInt.lhs)
1146 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1147         [ readClassKey
1148         ]
1149
1150 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1151 -- and are: "classes defined in the Prelude or a standard library"
1152 standardClassKeys = derivableClassKeys ++ numericClassKeys
1153                   ++ [randomClassKey, randomGenClassKey,
1154                       functorClassKey,
1155                       monadClassKey, monadPlusClassKey,
1156                       isStringClassKey
1157                      ]
1158 \end{code}
1159
1160 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1161 (@TcDeriv@).
1162
1163 \begin{code}
1164 derivableClassKeys
1165   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1166       boundedClassKey, showClassKey, readClassKey ]
1167 \end{code}
1168