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