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