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