compiler/prelude/PrelNames.lhs

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