compiler/prelude/PrelNames.lhs

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