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 ]
 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 closureTyConName    = tcQual   nDP_CLOSURE FSLIT(":->")    closureTyConKey
 696 mkClosureName       = varQual  nDP_CLOSURE FSLIT("mkClosure")  mkClosureIdKey
 697 applyClosureName    = varQual  nDP_CLOSURE FSLIT("$:")         applyClosureIdKey
 698 mkClosurePName      = varQual  nDP_CLOSURE FSLIT("mkClosureP") mkClosurePIdKey
 699 applyClosurePName   = varQual  nDP_CLOSURE FSLIT("$:^")        applyClosurePIdKey
 700 \end{code}
 701
 702 %************************************************************************
 703 %*                                                                      *
 704 \subsection{Local helpers}
 705 %*                                                                      *
 706 %************************************************************************
 707
 708 All these are original names; hence mkOrig
 709
 710 \begin{code}
 711 varQual  = mk_known_key_name varName
 712 tcQual   = mk_known_key_name tcName
 713 clsQual  = mk_known_key_name clsName
 714
 715 mk_known_key_name space mod str uniq
 716   = mkExternalName uniq mod (mkOccNameFS space str) noSrcSpan
 717
 718 conName :: Module -> FastString -> Unique -> Name
 719 conName mod occ uniq
 720   = mkExternalName uniq mod (mkOccNameFS dataName occ) noSrcSpan
 721
 722 methName :: Module -> FastString -> Unique -> Name
 723 methName mod occ uniq
 724   = mkExternalName uniq mod (mkVarOccFS occ) noSrcSpan
 725 \end{code}
 726
 727 %************************************************************************
 728 %*                                                                      *
 729 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 730 %*                                                                      *
 731 %************************************************************************
 732 --MetaHaskell extension hand allocate keys here
 733
 734 \begin{code}
 735 boundedClassKey         = mkPreludeClassUnique 1
 736 enumClassKey            = mkPreludeClassUnique 2
 737 eqClassKey              = mkPreludeClassUnique 3
 738 floatingClassKey        = mkPreludeClassUnique 5
 739 fractionalClassKey      = mkPreludeClassUnique 6
 740 integralClassKey        = mkPreludeClassUnique 7
 741 monadClassKey           = mkPreludeClassUnique 8
 742 dataClassKey            = mkPreludeClassUnique 9
 743 functorClassKey         = mkPreludeClassUnique 10
 744 numClassKey             = mkPreludeClassUnique 11
 745 ordClassKey             = mkPreludeClassUnique 12
 746 readClassKey            = mkPreludeClassUnique 13
 747 realClassKey            = mkPreludeClassUnique 14
 748 realFloatClassKey       = mkPreludeClassUnique 15
 749 realFracClassKey        = mkPreludeClassUnique 16
 750 showClassKey            = mkPreludeClassUnique 17
 751 ixClassKey              = mkPreludeClassUnique 18
 752
 753 typeableClassKey        = mkPreludeClassUnique 20
 754 typeable1ClassKey       = mkPreludeClassUnique 21
 755 typeable2ClassKey       = mkPreludeClassUnique 22
 756 typeable3ClassKey       = mkPreludeClassUnique 23
 757 typeable4ClassKey       = mkPreludeClassUnique 24
 758 typeable5ClassKey       = mkPreludeClassUnique 25
 759 typeable6ClassKey       = mkPreludeClassUnique 26
 760 typeable7ClassKey       = mkPreludeClassUnique 27
 761
 762 monadFixClassKey        = mkPreludeClassUnique 28
 763
 764 monadPlusClassKey       = mkPreludeClassUnique 30
 765 randomClassKey          = mkPreludeClassUnique 31
 766 randomGenClassKey       = mkPreludeClassUnique 32
 767
 768 isStringClassKey        = mkPreludeClassUnique 33
 769
 770 paClassKey              = mkPreludeClassUnique 34
 771 \end{code}
 772
 773 %************************************************************************
 774 %*                                                                      *
 775 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 776 %*                                                                      *
 777 %************************************************************************
 778
 779 \begin{code}
 780 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 781 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 782 boolTyConKey                            = mkPreludeTyConUnique  4
 783 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 784 charPrimTyConKey                        = mkPreludeTyConUnique  7
 785 charTyConKey                            = mkPreludeTyConUnique  8
 786 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 787 doubleTyConKey                          = mkPreludeTyConUnique 10
 788 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 789 floatTyConKey                           = mkPreludeTyConUnique 12
 790 funTyConKey                             = mkPreludeTyConUnique 13
 791 intPrimTyConKey                         = mkPreludeTyConUnique 14
 792 intTyConKey                             = mkPreludeTyConUnique 15
 793 int8TyConKey                            = mkPreludeTyConUnique 16
 794 int16TyConKey                           = mkPreludeTyConUnique 17
 795 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 796 int32TyConKey                           = mkPreludeTyConUnique 19
 797 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 798 int64TyConKey                           = mkPreludeTyConUnique 21
 799 integerTyConKey                         = mkPreludeTyConUnique 22
 800 listTyConKey                            = mkPreludeTyConUnique 23
 801 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 802 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 803 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 804 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 805 orderingTyConKey                        = mkPreludeTyConUnique 30
 806 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 807 ratioTyConKey                           = mkPreludeTyConUnique 32
 808 rationalTyConKey                        = mkPreludeTyConUnique 33
 809 realWorldTyConKey                       = mkPreludeTyConUnique 34
 810 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 811 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 812
 813 anyPrimTyConKey                         = mkPreludeTyConUnique 37
 814 anyPrimTyCon1Key                        = mkPreludeTyConUnique 38
 815
 816 statePrimTyConKey                       = mkPreludeTyConUnique 50
 817 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 818 stableNameTyConKey                      = mkPreludeTyConUnique 52
 819 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 820 ioTyConKey                              = mkPreludeTyConUnique 56
 821 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 822 wordTyConKey                            = mkPreludeTyConUnique 59
 823 word8TyConKey                           = mkPreludeTyConUnique 60
 824 word16TyConKey                          = mkPreludeTyConUnique 61
 825 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 826 word32TyConKey                          = mkPreludeTyConUnique 63
 827 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 828 word64TyConKey                          = mkPreludeTyConUnique 65
 829 liftedConKey                            = mkPreludeTyConUnique 66
 830 unliftedConKey                          = mkPreludeTyConUnique 67
 831 anyBoxConKey                            = mkPreludeTyConUnique 68
 832 kindConKey                              = mkPreludeTyConUnique 69
 833 boxityConKey                            = mkPreludeTyConUnique 70
 834 typeConKey                              = mkPreludeTyConUnique 71
 835 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 836 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 837 ptrTyConKey                             = mkPreludeTyConUnique 74
 838 funPtrTyConKey                          = mkPreludeTyConUnique 75
 839 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
 840
 841 -- Generic Type Constructors
 842 crossTyConKey                           = mkPreludeTyConUnique 79
 843 plusTyConKey                            = mkPreludeTyConUnique 80
 844 genUnitTyConKey                         = mkPreludeTyConUnique 81
 845
 846 -- Parallel array type constructor
 847 parrTyConKey                            = mkPreludeTyConUnique 82
 848
 849 -- dotnet interop
 850 objectTyConKey                          = mkPreludeTyConUnique 83
 851
 852 eitherTyConKey                          = mkPreludeTyConUnique 84
 853
 854 -- Super Kinds constructors
 855 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
 856 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
 857
 858 -- Kind constructors
 859 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
 860 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
 861 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
 862 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
 863 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
 864
 865 -- Coercion constructors
 866 symCoercionTyConKey                     = mkPreludeTyConUnique 93
 867 transCoercionTyConKey                   = mkPreludeTyConUnique 94
 868 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
 869 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
 870 instCoercionTyConKey                    = mkPreludeTyConUnique 97
 871 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
 872
 873 unknownTyConKey                         = mkPreludeTyConUnique 99
 874 unknown1TyConKey                        = mkPreludeTyConUnique 130
 875 unknown2TyConKey                        = mkPreludeTyConUnique 131
 876 unknown3TyConKey                        = mkPreludeTyConUnique 132
 877 opaqueTyConKey                          = mkPreludeTyConUnique 133
 878
 879 stringTyConKey                          = mkPreludeTyConUnique 134
 880
 881 parrayTyConKey                          = mkPreludeTyConUnique 135
 882 closureTyConKey                         = mkPreludeTyConUnique 136
 883
 884
 885 ---------------- Template Haskell -------------------
 886 --      USES TyConUniques 100-129
 887 -----------------------------------------------------
 888
 889 unitTyConKey = mkTupleTyConUnique Boxed 0
 890 \end{code}
 891
 892 %************************************************************************
 893 %*                                                                      *
 894 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 895 %*                                                                      *
 896 %************************************************************************
 897
 898 \begin{code}
 899 charDataConKey                          = mkPreludeDataConUnique  1
 900 consDataConKey                          = mkPreludeDataConUnique  2
 901 doubleDataConKey                        = mkPreludeDataConUnique  3
 902 falseDataConKey                         = mkPreludeDataConUnique  4
 903 floatDataConKey                         = mkPreludeDataConUnique  5
 904 intDataConKey                           = mkPreludeDataConUnique  6
 905 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 906 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 907 nilDataConKey                           = mkPreludeDataConUnique 11
 908 ratioDataConKey                         = mkPreludeDataConUnique 12
 909 stableNameDataConKey                    = mkPreludeDataConUnique 14
 910 trueDataConKey                          = mkPreludeDataConUnique 15
 911 wordDataConKey                          = mkPreludeDataConUnique 16
 912 ioDataConKey                            = mkPreludeDataConUnique 17
 913
 914 -- Generic data constructors
 915 crossDataConKey                         = mkPreludeDataConUnique 20
 916 inlDataConKey                           = mkPreludeDataConUnique 21
 917 inrDataConKey                           = mkPreludeDataConUnique 22
 918 genUnitDataConKey                       = mkPreludeDataConUnique 23
 919
 920 -- Data constructor for parallel arrays
 921 parrDataConKey                          = mkPreludeDataConUnique 24
 922
 923 leftDataConKey                          = mkPreludeDataConUnique 25
 924 rightDataConKey                         = mkPreludeDataConUnique 26
 925 \end{code}
 926
 927 %************************************************************************
 928 %*                                                                      *
 929 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 930 %*                                                                      *
 931 %************************************************************************
 932
 933 \begin{code}
 934 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 935 augmentIdKey                  = mkPreludeMiscIdUnique  3
 936 appendIdKey                   = mkPreludeMiscIdUnique  4
 937 buildIdKey                    = mkPreludeMiscIdUnique  5
 938 errorIdKey                    = mkPreludeMiscIdUnique  6
 939 foldlIdKey                    = mkPreludeMiscIdUnique  7
 940 foldrIdKey                    = mkPreludeMiscIdUnique  8
 941 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
 942 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
 943 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
 944 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
 945 integerZeroIdKey              = mkPreludeMiscIdUnique 13
 946 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
 947 seqIdKey                      = mkPreludeMiscIdUnique 15
 948 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 949 eqStringIdKey                 = mkPreludeMiscIdUnique 17
 950 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
 951 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
 952 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
 953 parErrorIdKey                 = mkPreludeMiscIdUnique 21
 954 parIdKey                      = mkPreludeMiscIdUnique 22
 955 patErrorIdKey                 = mkPreludeMiscIdUnique 23
 956 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
 957 recConErrorIdKey              = mkPreludeMiscIdUnique 25
 958 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
 959 traceIdKey                    = mkPreludeMiscIdUnique 27
 960 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
 961 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
 962 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
 963 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
 964
 965 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 966 concatIdKey                   = mkPreludeMiscIdUnique 33
 967 filterIdKey                   = mkPreludeMiscIdUnique 34
 968 zipIdKey                      = mkPreludeMiscIdUnique 35
 969 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 970 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 971 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 972 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 973 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 974 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 975 printIdKey                    = mkPreludeMiscIdUnique 43
 976 failIOIdKey                   = mkPreludeMiscIdUnique 44
 977 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
 978 voidArgIdKey                  = mkPreludeMiscIdUnique 47
 979 fstIdKey                      = mkPreludeMiscIdUnique 49
 980 sndIdKey                      = mkPreludeMiscIdUnique 50
 981 otherwiseIdKey                = mkPreludeMiscIdUnique 51
 982 assertIdKey                   = mkPreludeMiscIdUnique 53
 983 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
 984
 985 rootMainKey                   = mkPreludeMiscIdUnique 55
 986 runMainKey                    = mkPreludeMiscIdUnique 56
 987
 988 andIdKey                      = mkPreludeMiscIdUnique 57
 989 orIdKey                       = mkPreludeMiscIdUnique 58
 990 thenIOIdKey                   = mkPreludeMiscIdUnique 59
 991 lazyIdKey                     = mkPreludeMiscIdUnique 60
 992 assertErrorIdKey              = mkPreludeMiscIdUnique 61
 993
 994 breakpointIdKey               = mkPreludeMiscIdUnique 62
 995 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
 996 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
 997 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
 998 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
 999 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1000
1001 inlineIdKey                   = mkPreludeMiscIdUnique 68
1002
1003 -- Parallel array functions
1004 nullPIdKey                    = mkPreludeMiscIdUnique 80
1005 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1006 replicatePIdKey               = mkPreludeMiscIdUnique 82
1007 mapPIdKey                     = mkPreludeMiscIdUnique 83
1008 filterPIdKey                  = mkPreludeMiscIdUnique 84
1009 zipPIdKey                     = mkPreludeMiscIdUnique 85
1010 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1011 indexPIdKey                   = mkPreludeMiscIdUnique 87
1012 toPIdKey                      = mkPreludeMiscIdUnique 88
1013 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1014 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1015 bpermutePIdKey                = mkPreludeMiscIdUnique 91
1016 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
1017 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
1018
1019 -- dotnet interop
1020 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1021 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1022 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1023 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1024 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1025
1026 \end{code}
1027
1028 Certain class operations from Prelude classes.  They get their own
1029 uniques so we can look them up easily when we want to conjure them up
1030 during type checking.
1031
1032 \begin{code}
1033         -- Just a place holder for  unbound variables  produced by the renamer:
1034 unboundKey                    = mkPreludeMiscIdUnique 101
1035
1036 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1037 minusClassOpKey               = mkPreludeMiscIdUnique 103
1038 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1039 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1040 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1041 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1042 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1043 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1044 geClassOpKey                  = mkPreludeMiscIdUnique 110
1045 negateClassOpKey              = mkPreludeMiscIdUnique 111
1046 failMClassOpKey               = mkPreludeMiscIdUnique 112
1047 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1048 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1049 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1050
1051 -- Recursive do notation
1052 mfixIdKey       = mkPreludeMiscIdUnique 118
1053
1054 -- Arrow notation
1055 arrAIdKey       = mkPreludeMiscIdUnique 119
1056 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1057 firstAIdKey     = mkPreludeMiscIdUnique 121
1058 appAIdKey       = mkPreludeMiscIdUnique 122
1059 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1060 loopAIdKey      = mkPreludeMiscIdUnique 124
1061
1062 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1063
1064 -- Flattened parallel array functions
1065 mkClosureIdKey                = mkPreludeMiscIdUnique 126
1066 applyClosureIdKey             = mkPreludeMiscIdUnique 127
1067 mkClosurePIdKey               = mkPreludeMiscIdUnique 128
1068 applyClosurePIdKey            = mkPreludeMiscIdUnique 129
1069 closurePAIdKey                = mkPreludeMiscIdUnique 130
1070 lengthPAClassOpKey            = mkPreludeMiscIdUnique 131
1071 replicatePAClassOpKey         = mkPreludeMiscIdUnique 132
1072
1073 ---------------- Template Haskell -------------------
1074 --      USES IdUniques 200-399
1075 -----------------------------------------------------
1076 \end{code}
1077
1078
1079 %************************************************************************
1080 %*                                                                      *
1081 \subsection{Standard groups of types}
1082 %*                                                                      *
1083 %************************************************************************
1084
1085 \begin{code}
1086 numericTyKeys =
1087         [ wordTyConKey
1088         , intTyConKey
1089         , integerTyConKey
1090         , doubleTyConKey
1091         , floatTyConKey
1092         ]
1093 \end{code}
1094
1095
1096 %************************************************************************
1097 %*                                                                      *
1098 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1099 %*                                                                      *
1100 %************************************************************************
1101
1102 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1103 even though every numeric class has these two as a superclass,
1104 because the list of ambiguous dictionaries hasn't been simplified.
1105
1106 \begin{code}
1107 numericClassKeys =
1108         [ numClassKey
1109         , realClassKey
1110         , integralClassKey
1111         ]
1112         ++ fractionalClassKeys
1113
1114 fractionalClassKeys =
1115         [ fractionalClassKey
1116         , floatingClassKey
1117         , realFracClassKey
1118         , realFloatClassKey
1119         ]
1120
1121         -- the strictness analyser needs to know about numeric types
1122         -- (see SaAbsInt.lhs)
1123 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1124         [ readClassKey
1125         ]
1126
1127 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1128 -- and are: "classes defined in the Prelude or a standard library"
1129 standardClassKeys = derivableClassKeys ++ numericClassKeys
1130                   ++ [randomClassKey, randomGenClassKey,
1131                       functorClassKey,
1132                       monadClassKey, monadPlusClassKey,
1133                       isStringClassKey
1134                      ]
1135 \end{code}
1136
1137 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1138 (@TcDeriv@).
1139
1140 \begin{code}
1141 derivableClassKeys
1142   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1143       boundedClassKey, showClassKey, readClassKey ]
1144 \end{code}
1145