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