compiler/prelude/PrelNames.lhs

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