compiler/prelude/PrelNames.lhs

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