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