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