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