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