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, 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 runMainIOName :: Name
 546 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
 547
 548 orderingTyConName :: Name
 549 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
 550
 551 eitherTyConName, leftDataConName, rightDataConName :: Name
 552 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
 553 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
 554 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
 555
 556 -- Generics
 557 crossTyConName, plusTyConName, genUnitTyConName :: Name
 558 crossTyConName     = tcQual   gHC_GENERICS (fsLit ":*:") crossTyConKey
 559 plusTyConName      = tcQual   gHC_GENERICS (fsLit ":+:") plusTyConKey
 560 genUnitTyConName   = tcQual   gHC_GENERICS (fsLit "Unit") genUnitTyConKey
 561
 562 -- Base strings Strings
 563 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
 564     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
 565 unpackCStringName       = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
 566 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
 567 unpackCStringFoldrName  = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
 568 unpackCStringUtf8Name   = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
 569 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
 570 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
 571
 572 -- The 'inline' function
 573 inlineIdName :: Name
 574 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
 575
 576 -- Base classes (Eq, Ord, Functor)
 577 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
 578 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
 579 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
 580 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
 581 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
 582 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
 583
 584 -- Class Monad
 585 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
 586 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
 587 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
 588 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
 589 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
 590 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
 591
 592 -- Classes (Applicative, Foldable, Traversable)
 593 applicativeClassName, foldableClassName, traversableClassName :: Name
 594 applicativeClassName  = clsQual  cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
 595 foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey
 596 traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey
 597
 598 -- Functions for GHC extensions
 599 groupWithName :: Name
 600 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
 601
 602 -- Random PrelBase functions
 603 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
 604     mapName, appendName, assertName,
 605     breakpointName, breakpointCondName, breakpointAutoName,
 606     dollarName, opaqueTyConName :: Name
 607 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
 608 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
 609 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
 610 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
 611 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
 612 mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey
 613 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
 614 dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey
 615 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
 616 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
 617 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
 618 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
 619 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
 620
 621 breakpointJumpName :: Name
 622 breakpointJumpName
 623     = mkInternalName
 624         breakpointJumpIdKey
 625         (mkOccNameFS varName (fsLit "breakpointJump"))
 626         noSrcSpan
 627 breakpointCondJumpName :: Name
 628 breakpointCondJumpName
 629     = mkInternalName
 630         breakpointCondJumpIdKey
 631         (mkOccNameFS varName (fsLit "breakpointCondJump"))
 632         noSrcSpan
 633 breakpointAutoJumpName :: Name
 634 breakpointAutoJumpName
 635     = mkInternalName
 636         breakpointAutoJumpIdKey
 637         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
 638         noSrcSpan
 639
 640 -- PrelTup
 641 fstName, sndName :: Name
 642 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
 643 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
 644
 645 -- Module GHC.Num
 646 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
 647     timesIntegerName,
 648     integerTyConName, smallIntegerName :: Name
 649 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
 650 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
 651 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
 652 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
 653 plusIntegerName   = varQual  gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
 654 timesIntegerName  = varQual  gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
 655 integerTyConName  = tcQual   gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
 656 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
 657
 658 -- GHC.Real types and classes
 659 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
 660     integralClassName, realFracClassName, fractionalClassName,
 661     fromRationalName, toIntegerName, toRationalName, fromIntegralName,
 662     realToFracName :: Name
 663 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
 664 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
 665 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
 666 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
 667 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
 668 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
 669 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
 670 fromRationalName    = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
 671 toIntegerName       = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
 672 toRationalName      = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
 673 fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
 674 realToFracName      = varQual  gHC_REAL (fsLit "realToFrac") realToFracIdKey
 675
 676 -- PrelFloat classes
 677 floatingClassName, realFloatClassName :: Name
 678 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
 679 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
 680
 681 -- Class Ix
 682 ixClassName :: Name
 683 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
 684
 685 -- Class Typeable
 686 typeableClassName, typeable1ClassName, typeable2ClassName,
 687     typeable3ClassName, typeable4ClassName, typeable5ClassName,
 688     typeable6ClassName, typeable7ClassName :: Name
 689 typeableClassName  = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
 690 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
 691 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
 692 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
 693 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
 694 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
 695 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
 696 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
 697
 698 typeableClassNames :: [Name]
 699 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 700                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 701                         , typeable6ClassName, typeable7ClassName ]
 702
 703 -- Class Data
 704 dataClassName :: Name
 705 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
 706
 707 -- Error module
 708 assertErrorName    :: Name
 709 assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
 710
 711 -- Enum module (Enum, Bounded)
 712 enumClassName, enumFromName, enumFromToName, enumFromThenName,
 713     enumFromThenToName, boundedClassName :: Name
 714 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
 715 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
 716 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
 717 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
 718 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
 719 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
 720
 721 -- List functions
 722 concatName, filterName, zipName :: Name
 723 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
 724 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
 725 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
 726
 727 -- Class Show
 728 showClassName :: Name
 729 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
 730
 731 -- Class Read
 732 readClassName :: Name
 733 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
 734
 735 -- parallel array types and functions
 736 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
 737     singletonPName, replicatePName, mapPName, filterPName,
 738     zipPName, crossMapPName, indexPName, toPName,
 739     emptyPName, appPName :: Name
 740 enumFromToPName    = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
 741 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
 742 nullPName         = varQual gHC_PARR (fsLit "nullP")             nullPIdKey
 743 lengthPName       = varQual gHC_PARR (fsLit "lengthP")           lengthPIdKey
 744 singletonPName    = varQual gHC_PARR (fsLit "singletonP")         singletonPIdKey
 745 replicatePName    = varQual gHC_PARR (fsLit "replicateP")        replicatePIdKey
 746 mapPName          = varQual gHC_PARR (fsLit "mapP")              mapPIdKey
 747 filterPName       = varQual gHC_PARR (fsLit "filterP")           filterPIdKey
 748 zipPName          = varQual gHC_PARR (fsLit "zipP")              zipPIdKey
 749 crossMapPName     = varQual gHC_PARR (fsLit "crossMapP")         crossMapPIdKey
 750 indexPName        = varQual gHC_PARR (fsLit "!:")                indexPIdKey
 751 toPName           = varQual gHC_PARR (fsLit "toP")               toPIdKey
 752 emptyPName        = varQual gHC_PARR (fsLit "emptyP")            emptyPIdKey
 753 appPName          = varQual gHC_PARR (fsLit "+:+")               appPIdKey
 754
 755 -- IO things
 756 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
 757     failIOName :: Name
 758 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
 759 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
 760 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
 761 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
 762 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
 763 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
 764
 765 -- IO things
 766 printName :: Name
 767 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
 768
 769 -- Int, Word, and Addr things
 770 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
 771 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
 772 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
 773 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
 774 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
 775
 776 -- Word module
 777 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 778     wordTyConName, wordDataConName :: Name
 779 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
 780 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
 781 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
 782 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
 783 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
 784 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
 785
 786 -- PrelPtr module
 787 ptrTyConName, funPtrTyConName :: Name
 788 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
 789 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
 790
 791 -- Foreign objects and weak pointers
 792 stablePtrTyConName, newStablePtrName :: Name
 793 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
 794 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
 795
 796 -- PrelST module
 797 runSTRepName :: Name
 798 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
 799
 800 -- Recursive-do notation
 801 monadFixClassName, mfixName :: Name
 802 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
 803 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
 804
 805 -- Arrow notation
 806 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
 807 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
 808 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
 809 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
 810 appAName           = varQual aRROW (fsLit "app")          appAIdKey
 811 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
 812 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
 813
 814 -- Annotation type checking
 815 toAnnotationWrapperName :: Name
 816 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
 817
 818 -- Other classes, needed for type defaulting
 819 monadPlusClassName, randomClassName, randomGenClassName,
 820     isStringClassName :: Name
 821 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 822 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 823 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 824 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 825
 826 -- dotnet interop
 827 objectTyConName :: Name
 828 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 829         -- objectTyConName was "wTcQual", but that's gone now, and
 830         -- I can't see why it was wired in anyway...
 831 unmarshalObjectName, marshalObjectName, marshalStringName,
 832     unmarshalStringName, checkDotnetResName :: Name
 833 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 834 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 835 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 836 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 837 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 838 \end{code}
 839
 840 %************************************************************************
 841 %*                                                                      *
 842 \subsection{Local helpers}
 843 %*                                                                      *
 844 %************************************************************************
 845
 846 All these are original names; hence mkOrig
 847
 848 \begin{code}
 849 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 850 varQual  = mk_known_key_name varName
 851 tcQual   = mk_known_key_name tcName
 852 clsQual  = mk_known_key_name clsName
 853
 854 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 855 mk_known_key_name space modu str unique
 856   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 857
 858 conName :: Module -> FastString -> Unique -> Name
 859 conName modu occ unique
 860   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
 861
 862 methName :: Module -> FastString -> Unique -> Name
 863 methName modu occ unique
 864   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
 865 \end{code}
 866
 867 %************************************************************************
 868 %*                                                                      *
 869 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 870 %*                                                                      *
 871 %************************************************************************
 872 --MetaHaskell extension hand allocate keys here
 873
 874 \begin{code}
 875 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
 876     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
 877     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
 878     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
 879 boundedClassKey         = mkPreludeClassUnique 1
 880 enumClassKey            = mkPreludeClassUnique 2
 881 eqClassKey              = mkPreludeClassUnique 3
 882 floatingClassKey        = mkPreludeClassUnique 5
 883 fractionalClassKey      = mkPreludeClassUnique 6
 884 integralClassKey        = mkPreludeClassUnique 7
 885 monadClassKey           = mkPreludeClassUnique 8
 886 dataClassKey            = mkPreludeClassUnique 9
 887 functorClassKey         = mkPreludeClassUnique 10
 888 numClassKey             = mkPreludeClassUnique 11
 889 ordClassKey             = mkPreludeClassUnique 12
 890 readClassKey            = mkPreludeClassUnique 13
 891 realClassKey            = mkPreludeClassUnique 14
 892 realFloatClassKey       = mkPreludeClassUnique 15
 893 realFracClassKey        = mkPreludeClassUnique 16
 894 showClassKey            = mkPreludeClassUnique 17
 895 ixClassKey              = mkPreludeClassUnique 18
 896
 897 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
 898     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
 899     :: Unique
 900 typeableClassKey        = mkPreludeClassUnique 20
 901 typeable1ClassKey       = mkPreludeClassUnique 21
 902 typeable2ClassKey       = mkPreludeClassUnique 22
 903 typeable3ClassKey       = mkPreludeClassUnique 23
 904 typeable4ClassKey       = mkPreludeClassUnique 24
 905 typeable5ClassKey       = mkPreludeClassUnique 25
 906 typeable6ClassKey       = mkPreludeClassUnique 26
 907 typeable7ClassKey       = mkPreludeClassUnique 27
 908
 909 monadFixClassKey :: Unique
 910 monadFixClassKey        = mkPreludeClassUnique 28
 911
 912 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
 913 monadPlusClassKey       = mkPreludeClassUnique 30
 914 randomClassKey          = mkPreludeClassUnique 31
 915 randomGenClassKey       = mkPreludeClassUnique 32
 916
 917 isStringClassKey :: Unique
 918 isStringClassKey        = mkPreludeClassUnique 33
 919
 920 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
 921 applicativeClassKey     = mkPreludeClassUnique 34
 922 foldableClassKey        = mkPreludeClassUnique 35
 923 traversableClassKey     = mkPreludeClassUnique 36
 924 \end{code}
 925
 926 %************************************************************************
 927 %*                                                                      *
 928 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 929 %*                                                                      *
 930 %************************************************************************
 931
 932 \begin{code}
 933 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
 934     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
 935     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
 936     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
 937     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
 938     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
 939     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
 940     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
 941     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
 942     anyTyConKey :: Unique
 943 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 944 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 945 boolTyConKey                            = mkPreludeTyConUnique  4
 946 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 947 charPrimTyConKey                        = mkPreludeTyConUnique  7
 948 charTyConKey                            = mkPreludeTyConUnique  8
 949 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 950 doubleTyConKey                          = mkPreludeTyConUnique 10
 951 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 952 floatTyConKey                           = mkPreludeTyConUnique 12
 953 funTyConKey                             = mkPreludeTyConUnique 13
 954 intPrimTyConKey                         = mkPreludeTyConUnique 14
 955 intTyConKey                             = mkPreludeTyConUnique 15
 956 int8TyConKey                            = mkPreludeTyConUnique 16
 957 int16TyConKey                           = mkPreludeTyConUnique 17
 958 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 959 int32TyConKey                           = mkPreludeTyConUnique 19
 960 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 961 int64TyConKey                           = mkPreludeTyConUnique 21
 962 integerTyConKey                         = mkPreludeTyConUnique 22
 963 listTyConKey                            = mkPreludeTyConUnique 23
 964 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 965 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 966 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 967 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 968 orderingTyConKey                        = mkPreludeTyConUnique 30
 969 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 970 ratioTyConKey                           = mkPreludeTyConUnique 32
 971 rationalTyConKey                        = mkPreludeTyConUnique 33
 972 realWorldTyConKey                       = mkPreludeTyConUnique 34
 973 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 974 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 975 anyTyConKey                             = mkPreludeTyConUnique 37
 976
 977 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
 978     mutVarPrimTyConKey, ioTyConKey,
 979     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
 980     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
 981     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
 982     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
 983     funPtrTyConKey, tVarPrimTyConKey :: Unique
 984 statePrimTyConKey                       = mkPreludeTyConUnique 50
 985 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 986 stableNameTyConKey                      = mkPreludeTyConUnique 52
 987 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 988 ioTyConKey                              = mkPreludeTyConUnique 56
 989 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 990 wordTyConKey                            = mkPreludeTyConUnique 59
 991 word8TyConKey                           = mkPreludeTyConUnique 60
 992 word16TyConKey                          = mkPreludeTyConUnique 61
 993 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 994 word32TyConKey                          = mkPreludeTyConUnique 63
 995 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 996 word64TyConKey                          = mkPreludeTyConUnique 65
 997 liftedConKey                            = mkPreludeTyConUnique 66
 998 unliftedConKey                          = mkPreludeTyConUnique 67
 999 anyBoxConKey                            = mkPreludeTyConUnique 68
1000 kindConKey                              = mkPreludeTyConUnique 69
1001 boxityConKey                            = mkPreludeTyConUnique 70
1002 typeConKey                              = mkPreludeTyConUnique 71
1003 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1004 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1005 ptrTyConKey                             = mkPreludeTyConUnique 74
1006 funPtrTyConKey                          = mkPreludeTyConUnique 75
1007 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1008
1009 -- Generic Type Constructors
1010 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1011 crossTyConKey                           = mkPreludeTyConUnique 79
1012 plusTyConKey                            = mkPreludeTyConUnique 80
1013 genUnitTyConKey                         = mkPreludeTyConUnique 81
1014
1015 -- Parallel array type constructor
1016 parrTyConKey :: Unique
1017 parrTyConKey                            = mkPreludeTyConUnique 82
1018
1019 -- dotnet interop
1020 objectTyConKey :: Unique
1021 objectTyConKey                          = mkPreludeTyConUnique 83
1022
1023 eitherTyConKey :: Unique
1024 eitherTyConKey                          = mkPreludeTyConUnique 84
1025
1026 -- Super Kinds constructors
1027 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1028 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
1029 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
1030
1031 -- Kind constructors
1032 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1033     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1034 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1035 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1036 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1037 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1038 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1039
1040 -- Coercion constructors
1041 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1042     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1043     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1044     :: Unique
1045 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1046 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1047 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1048 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1049 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1050 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1051 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1052 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1053 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1054
1055 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1056     opaqueTyConKey :: Unique
1057 unknownTyConKey                         = mkPreludeTyConUnique 129
1058 unknown1TyConKey                        = mkPreludeTyConUnique 130
1059 unknown2TyConKey                        = mkPreludeTyConUnique 131
1060 unknown3TyConKey                        = mkPreludeTyConUnique 132
1061 opaqueTyConKey                          = mkPreludeTyConUnique 133
1062
1063 stringTyConKey :: Unique
1064 stringTyConKey                          = mkPreludeTyConUnique 134
1065
1066 ---------------- Template Haskell -------------------
1067 --      USES TyConUniques 100-129
1068 -----------------------------------------------------
1069
1070 unitTyConKey :: Unique
1071 unitTyConKey = mkTupleTyConUnique Boxed 0
1072 \end{code}
1073
1074 %************************************************************************
1075 %*                                                                      *
1076 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1077 %*                                                                      *
1078 %************************************************************************
1079
1080 \begin{code}
1081 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1082     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1083     stableNameDataConKey, trueDataConKey, wordDataConKey,
1084     ioDataConKey, integerDataConKey :: Unique
1085 charDataConKey                          = mkPreludeDataConUnique  1
1086 consDataConKey                          = mkPreludeDataConUnique  2
1087 doubleDataConKey                        = mkPreludeDataConUnique  3
1088 falseDataConKey                         = mkPreludeDataConUnique  4
1089 floatDataConKey                         = mkPreludeDataConUnique  5
1090 intDataConKey                           = mkPreludeDataConUnique  6
1091 nilDataConKey                           = mkPreludeDataConUnique 11
1092 ratioDataConKey                         = mkPreludeDataConUnique 12
1093 stableNameDataConKey                    = mkPreludeDataConUnique 14
1094 trueDataConKey                          = mkPreludeDataConUnique 15
1095 wordDataConKey                          = mkPreludeDataConUnique 16
1096 ioDataConKey                            = mkPreludeDataConUnique 17
1097 integerDataConKey                       = mkPreludeDataConUnique 18
1098
1099 -- Generic data constructors
1100 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1101 crossDataConKey                         = mkPreludeDataConUnique 20
1102 inlDataConKey                           = mkPreludeDataConUnique 21
1103 inrDataConKey                           = mkPreludeDataConUnique 22
1104 genUnitDataConKey                       = mkPreludeDataConUnique 23
1105
1106 -- Data constructor for parallel arrays
1107 parrDataConKey :: Unique
1108 parrDataConKey                          = mkPreludeDataConUnique 24
1109
1110 leftDataConKey, rightDataConKey :: Unique
1111 leftDataConKey                          = mkPreludeDataConUnique 25
1112 rightDataConKey                         = mkPreludeDataConUnique 26
1113 \end{code}
1114
1115 %************************************************************************
1116 %*                                                                      *
1117 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1118 %*                                                                      *
1119 %************************************************************************
1120
1121 \begin{code}
1122 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1123     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1124     integerMinusOneIdKey, integerPlusOneIdKey,
1125     integerPlusTwoIdKey, integerZeroIdKey,
1126     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1127     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1128     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1129     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1130     traceIdKey,
1131     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1132     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1133 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1134 augmentIdKey                  = mkPreludeMiscIdUnique  3
1135 appendIdKey                   = mkPreludeMiscIdUnique  4
1136 buildIdKey                    = mkPreludeMiscIdUnique  5
1137 errorIdKey                    = mkPreludeMiscIdUnique  6
1138 foldlIdKey                    = mkPreludeMiscIdUnique  7
1139 foldrIdKey                    = mkPreludeMiscIdUnique  8
1140 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1141 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1142 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1143 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1144 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1145 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1146 seqIdKey                      = mkPreludeMiscIdUnique 15
1147 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1148 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1149 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1150 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1151 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1152 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1153 parIdKey                      = mkPreludeMiscIdUnique 22
1154 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1155 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1156 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1157 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1158 traceIdKey                    = mkPreludeMiscIdUnique 27
1159 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1160 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1161 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1162 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1163
1164 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1165     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1166     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1167     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1168     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1169 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1170 concatIdKey                   = mkPreludeMiscIdUnique 33
1171 filterIdKey                   = mkPreludeMiscIdUnique 34
1172 zipIdKey                      = mkPreludeMiscIdUnique 35
1173 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1174 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1175 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1176 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1177 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1178 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1179 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1180 printIdKey                    = mkPreludeMiscIdUnique 43
1181 failIOIdKey                   = mkPreludeMiscIdUnique 44
1182 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1183 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1184 fstIdKey                      = mkPreludeMiscIdUnique 49
1185 sndIdKey                      = mkPreludeMiscIdUnique 50
1186 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1187 assertIdKey                   = mkPreludeMiscIdUnique 53
1188 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1189
1190 rootMainKey, runMainKey :: Unique
1191 rootMainKey                   = mkPreludeMiscIdUnique 55
1192 runMainKey                    = mkPreludeMiscIdUnique 56
1193
1194 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1195 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1196 lazyIdKey                     = mkPreludeMiscIdUnique 60
1197 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1198
1199 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1200     breakpointJumpIdKey, breakpointCondJumpIdKey,
1201     breakpointAutoJumpIdKey :: Unique
1202 breakpointIdKey               = mkPreludeMiscIdUnique 62
1203 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1204 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1205 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1206 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1207 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1208
1209 inlineIdKey :: Unique
1210 inlineIdKey                   = mkPreludeMiscIdUnique 68
1211
1212 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1213 mapIdKey              = mkPreludeMiscIdUnique 69
1214 groupWithIdKey        = mkPreludeMiscIdUnique 70
1215 dollarIdKey           = mkPreludeMiscIdUnique 71
1216
1217 -- Parallel array functions
1218 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1219     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1220     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1221 singletonPIdKey               = mkPreludeMiscIdUnique 79
1222 nullPIdKey                    = mkPreludeMiscIdUnique 80
1223 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1224 replicatePIdKey               = mkPreludeMiscIdUnique 82
1225 mapPIdKey                     = mkPreludeMiscIdUnique 83
1226 filterPIdKey                  = mkPreludeMiscIdUnique 84
1227 zipPIdKey                     = mkPreludeMiscIdUnique 85
1228 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1229 indexPIdKey                   = mkPreludeMiscIdUnique 87
1230 toPIdKey                      = mkPreludeMiscIdUnique 88
1231 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1232 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1233 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1234 appPIdKey                     = mkPreludeMiscIdUnique 92
1235
1236 -- dotnet interop
1237 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1238     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1239 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1240 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1241 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1242 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1243 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1244
1245 \end{code}
1246
1247 Certain class operations from Prelude classes.  They get their own
1248 uniques so we can look them up easily when we want to conjure them up
1249 during type checking.
1250
1251 \begin{code}
1252         -- Just a place holder for  unbound variables  produced by the renamer:
1253 unboundKey :: Unique
1254 unboundKey                    = mkPreludeMiscIdUnique 101
1255
1256 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1257     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1258     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1259     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1260     :: Unique
1261 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1262 minusClassOpKey               = mkPreludeMiscIdUnique 103
1263 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1264 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1265 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1266 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1267 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1268 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1269 geClassOpKey                  = mkPreludeMiscIdUnique 110
1270 negateClassOpKey              = mkPreludeMiscIdUnique 111
1271 failMClassOpKey               = mkPreludeMiscIdUnique 112
1272 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1273 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1274 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1275
1276 -- Recursive do notation
1277 mfixIdKey :: Unique
1278 mfixIdKey       = mkPreludeMiscIdUnique 118
1279
1280 -- Arrow notation
1281 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1282     loopAIdKey :: Unique
1283 arrAIdKey       = mkPreludeMiscIdUnique 119
1284 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1285 firstAIdKey     = mkPreludeMiscIdUnique 121
1286 appAIdKey       = mkPreludeMiscIdUnique 122
1287 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1288 loopAIdKey      = mkPreludeMiscIdUnique 124
1289
1290 fromStringClassOpKey :: Unique
1291 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1292
1293 -- Annotation type checking
1294 toAnnotationWrapperIdKey :: Unique
1295 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 126
1296
1297 -- Conversion functions
1298 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1299 fromIntegralIdKey    = mkPreludeMiscIdUnique 127
1300 realToFracIdKey      = mkPreludeMiscIdUnique 128
1301 toIntegerClassOpKey  = mkPreludeMiscIdUnique 129
1302 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1303
1304 ---------------- Template Haskell -------------------
1305 --      USES IdUniques 200-399
1306 -----------------------------------------------------
1307 \end{code}
1308
1309
1310 %************************************************************************
1311 %*                                                                      *
1312 \subsection{Standard groups of types}
1313 %*                                                                      *
1314 %************************************************************************
1315
1316 \begin{code}
1317 numericTyKeys :: [Unique]
1318 numericTyKeys =
1319         [ wordTyConKey
1320         , intTyConKey
1321         , integerTyConKey
1322         , doubleTyConKey
1323         , floatTyConKey
1324         ]
1325
1326 kindKeys :: [Unique]
1327 kindKeys = [ liftedTypeKindTyConKey
1328            , openTypeKindTyConKey
1329            , unliftedTypeKindTyConKey
1330            , ubxTupleKindTyConKey
1331            , argTypeKindTyConKey ]
1332 \end{code}
1333
1334
1335 %************************************************************************
1336 %*                                                                      *
1337 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1338 %*                                                                      *
1339 %************************************************************************
1340
1341 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1342 even though every numeric class has these two as a superclass,
1343 because the list of ambiguous dictionaries hasn't been simplified.
1344
1345 \begin{code}
1346 numericClassKeys :: [Unique]
1347 numericClassKeys =
1348         [ numClassKey
1349         , realClassKey
1350         , integralClassKey
1351         ]
1352         ++ fractionalClassKeys
1353
1354 fractionalClassKeys :: [Unique]
1355 fractionalClassKeys =
1356         [ fractionalClassKey
1357         , floatingClassKey
1358         , realFracClassKey
1359         , realFloatClassKey
1360         ]
1361
1362         -- the strictness analyser needs to know about numeric types
1363         -- (see SaAbsInt.lhs)
1364 needsDataDeclCtxtClassKeys :: [Unique]
1365 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1366         [ readClassKey
1367         ]
1368
1369 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1370 -- and are: "classes defined in the Prelude or a standard library"
1371 standardClassKeys :: [Unique]
1372 standardClassKeys = derivableClassKeys ++ numericClassKeys
1373                   ++ [randomClassKey, randomGenClassKey,
1374                       functorClassKey,
1375                       monadClassKey, monadPlusClassKey,
1376                       isStringClassKey,
1377                       applicativeClassKey, foldableClassKey, traversableClassKey
1378                      ]
1379 \end{code}
1380
1381 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1382 (@TcDeriv@).
1383
1384 \begin{code}
1385 derivableClassKeys :: [Unique]
1386 derivableClassKeys
1387   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1388       boundedClassKey, showClassKey, readClassKey ]
1389 \end{code}
1390