compiler/prelude/PrelNames.lhs

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