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