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