compiler/prelude/PrelNames.lhs

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