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