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