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