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