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