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