compiler/prelude/PrelNames.lhs

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