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