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