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