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