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