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