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