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         -- 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_INTEGER_INTERNALS, 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_INTEGER_INTERNALS = mkIntegerModule (fsLit "GHC.Integer.Internals")
 255 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
 256 gHC_PARR        = mkBaseModule (fsLit "GHC.PArr")
 257 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
 258 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
 259 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
 260 dATA_STRING     = mkBaseModule (fsLit "Data.String")
 261 gHC_PACK        = mkBaseModule (fsLit "GHC.Pack")
 262 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
 263 gHC_IO_BASE     = mkBaseModule (fsLit "GHC.IOBase")
 264 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
 265 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
 266 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
 267 gHC_ADDR        = mkBaseModule (fsLit "GHC.Addr")
 268 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
 269 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
 270 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
 271 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
 272 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
 273 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
 274 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
 275 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
 276 gENERICS        = mkBaseModule (fsLit "Data.Data")
 277 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
 278 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
 279 lEX                 = mkBaseModule (fsLit "Text.Read.Lex")
 280 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
 281 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
 282 mONAD           = mkBaseModule (fsLit "Control.Monad")
 283 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
 284 aRROW           = mkBaseModule (fsLit "Control.Arrow")
 285 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
 286 rANDOM          = mkBaseModule (fsLit "System.Random")
 287 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
 288 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
 289
 290 mAIN, rOOT_MAIN :: Module
 291 mAIN            = mkMainModule_ mAIN_NAME
 292 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation
 293
 294         -- The ':xxx' makes a module name that the user can never
 295         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 296         -- module name still starts with a capital letter, which keeps
 297         -- the z-encoded version consistent.
 298 iNTERACTIVE :: Module
 299 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
 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_INTERNALS (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,
 709     emptyPName, appPName :: 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 emptyPName        = varQual gHC_PARR (fsLit "emptyP")            emptyPIdKey
 723 appPName          = varQual gHC_PARR (fsLit "+:+")               appPIdKey
 724
 725 -- IOBase things
 726 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
 727     failIOName :: Name
 728 ioTyConName       = tcQual  gHC_IO_BASE (fsLit "IO") ioTyConKey
 729 ioDataConName     = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
 730 thenIOName        = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
 731 bindIOName        = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
 732 returnIOName      = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
 733 failIOName        = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
 734
 735 -- IO things
 736 printName :: Name
 737 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
 738
 739 -- Int, Word, and Addr things
 740 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
 741 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
 742 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
 743 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
 744 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
 745
 746 -- Word module
 747 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 748     wordTyConName, wordDataConName :: Name
 749 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
 750 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
 751 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
 752 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
 753 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
 754 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
 755
 756 -- PrelPtr module
 757 ptrTyConName, funPtrTyConName :: Name
 758 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
 759 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
 760
 761 -- Foreign objects and weak pointers
 762 stablePtrTyConName, newStablePtrName :: Name
 763 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
 764 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
 765
 766 -- PrelST module
 767 runSTRepName :: Name
 768 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
 769
 770 -- Recursive-do notation
 771 monadFixClassName, mfixName :: Name
 772 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
 773 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
 774
 775 -- Arrow notation
 776 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
 777 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
 778 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
 779 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
 780 appAName           = varQual aRROW (fsLit "app")          appAIdKey
 781 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
 782 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
 783
 784 -- Other classes, needed for type defaulting
 785 monadPlusClassName, randomClassName, randomGenClassName,
 786     isStringClassName :: Name
 787 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 788 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 789 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 790 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 791
 792 -- dotnet interop
 793 objectTyConName :: Name
 794 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 795         -- objectTyConName was "wTcQual", but that's gone now, and
 796         -- I can't see why it was wired in anyway...
 797 unmarshalObjectName, marshalObjectName, marshalStringName,
 798     unmarshalStringName, checkDotnetResName :: Name
 799 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 800 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 801 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 802 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 803 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 804 \end{code}
 805
 806 %************************************************************************
 807 %*                                                                      *
 808 \subsection{Local helpers}
 809 %*                                                                      *
 810 %************************************************************************
 811
 812 All these are original names; hence mkOrig
 813
 814 \begin{code}
 815 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 816 varQual  = mk_known_key_name varName
 817 tcQual   = mk_known_key_name tcName
 818 clsQual  = mk_known_key_name clsName
 819
 820 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 821 mk_known_key_name space modu str unique
 822   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 823
 824 conName :: Module -> FastString -> Unique -> Name
 825 conName modu occ unique
 826   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
 827
 828 methName :: Module -> FastString -> Unique -> Name
 829 methName modu occ unique
 830   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
 831 \end{code}
 832
 833 %************************************************************************
 834 %*                                                                      *
 835 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 836 %*                                                                      *
 837 %************************************************************************
 838 --MetaHaskell extension hand allocate keys here
 839
 840 \begin{code}
 841 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
 842     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
 843     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
 844     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
 845 boundedClassKey         = mkPreludeClassUnique 1
 846 enumClassKey            = mkPreludeClassUnique 2
 847 eqClassKey              = mkPreludeClassUnique 3
 848 floatingClassKey        = mkPreludeClassUnique 5
 849 fractionalClassKey      = mkPreludeClassUnique 6
 850 integralClassKey        = mkPreludeClassUnique 7
 851 monadClassKey           = mkPreludeClassUnique 8
 852 dataClassKey            = mkPreludeClassUnique 9
 853 functorClassKey         = mkPreludeClassUnique 10
 854 numClassKey             = mkPreludeClassUnique 11
 855 ordClassKey             = mkPreludeClassUnique 12
 856 readClassKey            = mkPreludeClassUnique 13
 857 realClassKey            = mkPreludeClassUnique 14
 858 realFloatClassKey       = mkPreludeClassUnique 15
 859 realFracClassKey        = mkPreludeClassUnique 16
 860 showClassKey            = mkPreludeClassUnique 17
 861 ixClassKey              = mkPreludeClassUnique 18
 862
 863 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
 864     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
 865     :: Unique
 866 typeableClassKey        = mkPreludeClassUnique 20
 867 typeable1ClassKey       = mkPreludeClassUnique 21
 868 typeable2ClassKey       = mkPreludeClassUnique 22
 869 typeable3ClassKey       = mkPreludeClassUnique 23
 870 typeable4ClassKey       = mkPreludeClassUnique 24
 871 typeable5ClassKey       = mkPreludeClassUnique 25
 872 typeable6ClassKey       = mkPreludeClassUnique 26
 873 typeable7ClassKey       = mkPreludeClassUnique 27
 874
 875 monadFixClassKey :: Unique
 876 monadFixClassKey        = mkPreludeClassUnique 28
 877
 878 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
 879 monadPlusClassKey       = mkPreludeClassUnique 30
 880 randomClassKey          = mkPreludeClassUnique 31
 881 randomGenClassKey       = mkPreludeClassUnique 32
 882
 883 isStringClassKey :: Unique
 884 isStringClassKey        = mkPreludeClassUnique 33
 885 \end{code}
 886
 887 %************************************************************************
 888 %*                                                                      *
 889 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 890 %*                                                                      *
 891 %************************************************************************
 892
 893 \begin{code}
 894 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
 895     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
 896     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
 897     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
 898     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
 899     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
 900     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
 901     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
 902     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
 903 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 904 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 905 boolTyConKey                            = mkPreludeTyConUnique  4
 906 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 907 charPrimTyConKey                        = mkPreludeTyConUnique  7
 908 charTyConKey                            = mkPreludeTyConUnique  8
 909 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 910 doubleTyConKey                          = mkPreludeTyConUnique 10
 911 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 912 floatTyConKey                           = mkPreludeTyConUnique 12
 913 funTyConKey                             = mkPreludeTyConUnique 13
 914 intPrimTyConKey                         = mkPreludeTyConUnique 14
 915 intTyConKey                             = mkPreludeTyConUnique 15
 916 int8TyConKey                            = mkPreludeTyConUnique 16
 917 int16TyConKey                           = mkPreludeTyConUnique 17
 918 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 919 int32TyConKey                           = mkPreludeTyConUnique 19
 920 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 921 int64TyConKey                           = mkPreludeTyConUnique 21
 922 integerTyConKey                         = mkPreludeTyConUnique 22
 923 listTyConKey                            = mkPreludeTyConUnique 23
 924 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 925 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 926 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 927 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 928 orderingTyConKey                        = mkPreludeTyConUnique 30
 929 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 930 ratioTyConKey                           = mkPreludeTyConUnique 32
 931 rationalTyConKey                        = mkPreludeTyConUnique 33
 932 realWorldTyConKey                       = mkPreludeTyConUnique 34
 933 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 934 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 935
 936 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
 937 anyPrimTyConKey                         = mkPreludeTyConUnique 37
 938 anyPrimTyCon1Key                        = mkPreludeTyConUnique 38
 939
 940 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
 941     mutVarPrimTyConKey, ioTyConKey,
 942     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
 943     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
 944     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
 945     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
 946     funPtrTyConKey, tVarPrimTyConKey :: Unique
 947 statePrimTyConKey                       = mkPreludeTyConUnique 50
 948 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 949 stableNameTyConKey                      = mkPreludeTyConUnique 52
 950 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 951 ioTyConKey                              = mkPreludeTyConUnique 56
 952 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 953 wordTyConKey                            = mkPreludeTyConUnique 59
 954 word8TyConKey                           = mkPreludeTyConUnique 60
 955 word16TyConKey                          = mkPreludeTyConUnique 61
 956 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 957 word32TyConKey                          = mkPreludeTyConUnique 63
 958 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 959 word64TyConKey                          = mkPreludeTyConUnique 65
 960 liftedConKey                            = mkPreludeTyConUnique 66
 961 unliftedConKey                          = mkPreludeTyConUnique 67
 962 anyBoxConKey                            = mkPreludeTyConUnique 68
 963 kindConKey                              = mkPreludeTyConUnique 69
 964 boxityConKey                            = mkPreludeTyConUnique 70
 965 typeConKey                              = mkPreludeTyConUnique 71
 966 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 967 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 968 ptrTyConKey                             = mkPreludeTyConUnique 74
 969 funPtrTyConKey                          = mkPreludeTyConUnique 75
 970 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
 971
 972 -- Generic Type Constructors
 973 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
 974 crossTyConKey                           = mkPreludeTyConUnique 79
 975 plusTyConKey                            = mkPreludeTyConUnique 80
 976 genUnitTyConKey                         = mkPreludeTyConUnique 81
 977
 978 -- Parallel array type constructor
 979 parrTyConKey :: Unique
 980 parrTyConKey                            = mkPreludeTyConUnique 82
 981
 982 -- dotnet interop
 983 objectTyConKey :: Unique
 984 objectTyConKey                          = mkPreludeTyConUnique 83
 985
 986 eitherTyConKey :: Unique
 987 eitherTyConKey                          = mkPreludeTyConUnique 84
 988
 989 -- Super Kinds constructors
 990 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
 991 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
 992 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
 993
 994 -- Kind constructors
 995 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
 996     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
 997 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
 998 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
 999 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1000 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1001 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1002
1003 -- Coercion constructors
1004 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1005     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1006     :: Unique
1007 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1008 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1009 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1010 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1011 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1012 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1013
1014 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1015     opaqueTyConKey :: Unique
1016 unknownTyConKey                         = mkPreludeTyConUnique 99
1017 unknown1TyConKey                        = mkPreludeTyConUnique 130
1018 unknown2TyConKey                        = mkPreludeTyConUnique 131
1019 unknown3TyConKey                        = mkPreludeTyConUnique 132
1020 opaqueTyConKey                          = mkPreludeTyConUnique 133
1021
1022 stringTyConKey :: Unique
1023 stringTyConKey                          = mkPreludeTyConUnique 134
1024
1025 ---------------- Template Haskell -------------------
1026 --      USES TyConUniques 100-129
1027 -----------------------------------------------------
1028
1029 unitTyConKey :: Unique
1030 unitTyConKey = mkTupleTyConUnique Boxed 0
1031 \end{code}
1032
1033 %************************************************************************
1034 %*                                                                      *
1035 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1036 %*                                                                      *
1037 %************************************************************************
1038
1039 \begin{code}
1040 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1041     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1042     stableNameDataConKey, trueDataConKey, wordDataConKey,
1043     ioDataConKey :: Unique
1044 charDataConKey                          = mkPreludeDataConUnique  1
1045 consDataConKey                          = mkPreludeDataConUnique  2
1046 doubleDataConKey                        = mkPreludeDataConUnique  3
1047 falseDataConKey                         = mkPreludeDataConUnique  4
1048 floatDataConKey                         = mkPreludeDataConUnique  5
1049 intDataConKey                           = mkPreludeDataConUnique  6
1050 nilDataConKey                           = mkPreludeDataConUnique 11
1051 ratioDataConKey                         = mkPreludeDataConUnique 12
1052 stableNameDataConKey                    = mkPreludeDataConUnique 14
1053 trueDataConKey                          = mkPreludeDataConUnique 15
1054 wordDataConKey                          = mkPreludeDataConUnique 16
1055 ioDataConKey                            = mkPreludeDataConUnique 17
1056
1057 -- Generic data constructors
1058 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1059 crossDataConKey                         = mkPreludeDataConUnique 20
1060 inlDataConKey                           = mkPreludeDataConUnique 21
1061 inrDataConKey                           = mkPreludeDataConUnique 22
1062 genUnitDataConKey                       = mkPreludeDataConUnique 23
1063
1064 -- Data constructor for parallel arrays
1065 parrDataConKey :: Unique
1066 parrDataConKey                          = mkPreludeDataConUnique 24
1067
1068 leftDataConKey, rightDataConKey :: Unique
1069 leftDataConKey                          = mkPreludeDataConUnique 25
1070 rightDataConKey                         = mkPreludeDataConUnique 26
1071 \end{code}
1072
1073 %************************************************************************
1074 %*                                                                      *
1075 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1076 %*                                                                      *
1077 %************************************************************************
1078
1079 \begin{code}
1080 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1081     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1082     integerMinusOneIdKey, integerPlusOneIdKey,
1083     integerPlusTwoIdKey, integerZeroIdKey,
1084     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1085     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1086     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1087     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1088     traceIdKey,
1089     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1090     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1091 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1092 augmentIdKey                  = mkPreludeMiscIdUnique  3
1093 appendIdKey                   = mkPreludeMiscIdUnique  4
1094 buildIdKey                    = mkPreludeMiscIdUnique  5
1095 errorIdKey                    = mkPreludeMiscIdUnique  6
1096 foldlIdKey                    = mkPreludeMiscIdUnique  7
1097 foldrIdKey                    = mkPreludeMiscIdUnique  8
1098 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1099 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1100 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1101 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1102 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1103 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1104 seqIdKey                      = mkPreludeMiscIdUnique 15
1105 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1106 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1107 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1108 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1109 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1110 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1111 parIdKey                      = mkPreludeMiscIdUnique 22
1112 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1113 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1114 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1115 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1116 traceIdKey                    = mkPreludeMiscIdUnique 27
1117 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1118 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1119 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1120 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1121
1122 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1123     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1124     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1125     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1126     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1127 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1128 concatIdKey                   = mkPreludeMiscIdUnique 33
1129 filterIdKey                   = mkPreludeMiscIdUnique 34
1130 zipIdKey                      = mkPreludeMiscIdUnique 35
1131 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1132 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1133 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1134 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1135 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1136 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1137 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1138 printIdKey                    = mkPreludeMiscIdUnique 43
1139 failIOIdKey                   = mkPreludeMiscIdUnique 44
1140 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1141 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1142 fstIdKey                      = mkPreludeMiscIdUnique 49
1143 sndIdKey                      = mkPreludeMiscIdUnique 50
1144 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1145 assertIdKey                   = mkPreludeMiscIdUnique 53
1146 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1147
1148 rootMainKey, runMainKey :: Unique
1149 rootMainKey                   = mkPreludeMiscIdUnique 55
1150 runMainKey                    = mkPreludeMiscIdUnique 56
1151
1152 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1153 andIdKey                      = mkPreludeMiscIdUnique 57
1154 orIdKey                       = mkPreludeMiscIdUnique 58
1155 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1156 lazyIdKey                     = mkPreludeMiscIdUnique 60
1157 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1158
1159 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1160     breakpointJumpIdKey, breakpointCondJumpIdKey,
1161     breakpointAutoJumpIdKey :: Unique
1162 breakpointIdKey               = mkPreludeMiscIdUnique 62
1163 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1164 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1165 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1166 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1167 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1168
1169 inlineIdKey :: Unique
1170 inlineIdKey                   = mkPreludeMiscIdUnique 68
1171
1172 mapIdKey, groupWithIdKey :: Unique
1173 mapIdKey                      = mkPreludeMiscIdUnique 69
1174 groupWithIdKey        = mkPreludeMiscIdUnique 70
1175
1176 -- Parallel array functions
1177 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1178     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1179     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1180 singletonPIdKey               = mkPreludeMiscIdUnique 79
1181 nullPIdKey                    = mkPreludeMiscIdUnique 80
1182 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1183 replicatePIdKey               = mkPreludeMiscIdUnique 82
1184 mapPIdKey                     = mkPreludeMiscIdUnique 83
1185 filterPIdKey                  = mkPreludeMiscIdUnique 84
1186 zipPIdKey                     = mkPreludeMiscIdUnique 85
1187 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1188 indexPIdKey                   = mkPreludeMiscIdUnique 87
1189 toPIdKey                      = mkPreludeMiscIdUnique 88
1190 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1191 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1192 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1193 appPIdKey                     = mkPreludeMiscIdUnique 92
1194
1195 -- dotnet interop
1196 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1197     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1198 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1199 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1200 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1201 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1202 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1203
1204 \end{code}
1205
1206 Certain class operations from Prelude classes.  They get their own
1207 uniques so we can look them up easily when we want to conjure them up
1208 during type checking.
1209
1210 \begin{code}
1211         -- Just a place holder for  unbound variables  produced by the renamer:
1212 unboundKey :: Unique
1213 unboundKey                    = mkPreludeMiscIdUnique 101
1214
1215 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1216     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1217     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1218     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1219     :: Unique
1220 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1221 minusClassOpKey               = mkPreludeMiscIdUnique 103
1222 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1223 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1224 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1225 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1226 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1227 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1228 geClassOpKey                  = mkPreludeMiscIdUnique 110
1229 negateClassOpKey              = mkPreludeMiscIdUnique 111
1230 failMClassOpKey               = mkPreludeMiscIdUnique 112
1231 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1232 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1233 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1234
1235 -- Recursive do notation
1236 mfixIdKey :: Unique
1237 mfixIdKey       = mkPreludeMiscIdUnique 118
1238
1239 -- Arrow notation
1240 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1241     loopAIdKey :: Unique
1242 arrAIdKey       = mkPreludeMiscIdUnique 119
1243 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1244 firstAIdKey     = mkPreludeMiscIdUnique 121
1245 appAIdKey       = mkPreludeMiscIdUnique 122
1246 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1247 loopAIdKey      = mkPreludeMiscIdUnique 124
1248
1249 fromStringClassOpKey :: Unique
1250 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1251
1252 ---------------- Template Haskell -------------------
1253 --      USES IdUniques 200-399
1254 -----------------------------------------------------
1255 \end{code}
1256
1257
1258 %************************************************************************
1259 %*                                                                      *
1260 \subsection{Standard groups of types}
1261 %*                                                                      *
1262 %************************************************************************
1263
1264 \begin{code}
1265 numericTyKeys :: [Unique]
1266 numericTyKeys =
1267         [ wordTyConKey
1268         , intTyConKey
1269         , integerTyConKey
1270         , doubleTyConKey
1271         , floatTyConKey
1272         ]
1273 \end{code}
1274
1275
1276 %************************************************************************
1277 %*                                                                      *
1278 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1279 %*                                                                      *
1280 %************************************************************************
1281
1282 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1283 even though every numeric class has these two as a superclass,
1284 because the list of ambiguous dictionaries hasn't been simplified.
1285
1286 \begin{code}
1287 numericClassKeys :: [Unique]
1288 numericClassKeys =
1289         [ numClassKey
1290         , realClassKey
1291         , integralClassKey
1292         ]
1293         ++ fractionalClassKeys
1294
1295 fractionalClassKeys :: [Unique]
1296 fractionalClassKeys =
1297         [ fractionalClassKey
1298         , floatingClassKey
1299         , realFracClassKey
1300         , realFloatClassKey
1301         ]
1302
1303         -- the strictness analyser needs to know about numeric types
1304         -- (see SaAbsInt.lhs)
1305 needsDataDeclCtxtClassKeys :: [Unique]
1306 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1307         [ readClassKey
1308         ]
1309
1310 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1311 -- and are: "classes defined in the Prelude or a standard library"
1312 standardClassKeys :: [Unique]
1313 standardClassKeys = derivableClassKeys ++ numericClassKeys
1314                   ++ [randomClassKey, randomGenClassKey,
1315                       functorClassKey,
1316                       monadClassKey, monadPlusClassKey,
1317                       isStringClassKey
1318                      ]
1319 \end{code}
1320
1321 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1322 (@TcDeriv@).
1323
1324 \begin{code}
1325 derivableClassKeys :: [Unique]
1326 derivableClassKeys
1327   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1328       boundedClassKey, showClassKey, readClassKey ]
1329 \end{code}
1330