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