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