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