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