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