compiler/prelude/PrelNames.lhs

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