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