ghc/compiler/prelude/PrelNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[PrelNames]{Definitions of prelude modules}
   5
   6 The strings identify built-in prelude modules.  They are
   7 defined here so as to avod
   8
   9 [oh dear, looks like the recursive module monster caught up with
  10  and gobbled whoever was writing the above :-) -- SOF ]
  11
  12 \begin{code}
  13 module PrelNames (
  14         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
  15
  16         -----------------------------------------------------------
  17         module PrelNames,       -- A huge bunch of (a) RdrNames, e.g. intTyCon_RDR
  18                                 --                 (b) Uniques   e.g. intTyConKey
  19                                 -- So many that we export them all
  20
  21         -----------------------------------------------------------
  22         knownKeyNames,
  23         mkTupNameStr, mkTupConRdrName,
  24
  25         ------------------------------------------------------------
  26         -- Goups of classes and types
  27         needsDataDeclCtxtClassKeys, cCallishClassKeys, noDictClassKeys,
  28         fractionalClassKeys, numericClassKeys, standardClassKeys,
  29         derivingOccurrences,    -- For a given class C, this tells what other
  30         derivableClassKeys,     -- things are needed as a result of a
  31                                 -- deriving(C) clause
  32         numericTyKeys, cCallishTyKeys,
  33
  34         mkUnboundName, isUnboundName
  35     ) where
  36
  37 #include "HsVersions.h"
  38
  39 import Module     ( ModuleName, mkPrelModule, mkHomeModule, mkModuleName )
  40 import OccName    ( NameSpace, UserFS, varName, dataName, tcName, clsName,
  41                     mkKindOccFS, mkOccFS
  42                   )
  43 import RdrName    ( RdrName, mkOrig, mkUnqual )
  44 import UniqFM
  45 import Unique     ( Unique, Uniquable(..), hasKey,
  46                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
  47                     mkPreludeTyConUnique, mkPreludeClassUnique,
  48                     mkTupleTyConUnique
  49                   )
  50 import BasicTypes ( Boxity(..), Arity )
  51 import UniqFM     ( UniqFM, listToUFM )
  52 import Name       ( Name, mkLocalName, mkKnownKeyGlobal, nameRdrName )
  53 import RdrName    ( rdrNameOcc )
  54 import SrcLoc     ( builtinSrcLoc, noSrcLoc )
  55 import Util       ( nOfThem )
  56 import Panic      ( panic )
  57 \end{code}
  58
  59
  60 %************************************************************************
  61 %*                                                                      *
  62 \subsection{Local Names}
  63 %*                                                                      *
  64 %************************************************************************
  65
  66 This *local* name is used by the interactive stuff
  67
  68 \begin{code}
  69 itName uniq = mkLocalName uniq (mkOccFS varName SLIT("it")) noSrcLoc
  70 \end{code}
  71
  72 \begin{code}
  73 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
  74 -- during compiler debugging.
  75 mkUnboundName :: RdrName -> Name
  76 mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) builtinSrcLoc
  77
  78 isUnboundName :: Name -> Bool
  79 isUnboundName name = name `hasKey` unboundKey
  80 \end{code}
  81
  82
  83 %************************************************************************
  84 %*                                                                      *
  85 \subsection{Known key Names}
  86 %*                                                                      *
  87 %************************************************************************
  88
  89 This section tells what the compiler knows about the assocation of
  90 names with uniques.  These ones are the *non* wired-in ones.  The
  91 wired in ones are defined in TysWiredIn etc.
  92
  93 \begin{code}
  94 knownKeyNames :: [Name]
  95 knownKeyNames
  96  =  [
  97         -- Type constructors (synonyms especially)
  98         ioTyConName, ioDataConName,
  99         runMainName,
 100         orderingTyConName,
 101         rationalTyConName,
 102         ratioDataConName,
 103         ratioTyConName,
 104         byteArrayTyConName,
 105         mutableByteArrayTyConName,
 106         foreignObjTyConName,
 107         foreignPtrTyConName,
 108         bcoPrimTyConName,
 109         stablePtrTyConName,
 110         stablePtrDataConName,
 111
 112         --  Classes.  *Must* include:
 113         --      classes that are grabbed by key (e.g., eqClassKey)
 114         --      classes in "Class.standardClassKeys" (quite a few)
 115         eqClassName,                    -- mentioned, derivable
 116         ordClassName,                   -- derivable
 117         boundedClassName,               -- derivable
 118         numClassName,                   -- mentioned, numeric
 119         enumClassName,                  -- derivable
 120         monadClassName,
 121         monadPlusClassName,
 122         functorClassName,
 123         showClassName,                  -- derivable
 124         realClassName,                  -- numeric
 125         integralClassName,              -- numeric
 126         fractionalClassName,            -- numeric
 127         floatingClassName,              -- numeric
 128         realFracClassName,              -- numeric
 129         realFloatClassName,             -- numeric
 130         readClassName,                  -- derivable
 131         ixClassName,                    -- derivable (but it isn't Prelude.Ix; hmmm)
 132         cCallableClassName,             -- mentioned, ccallish
 133         cReturnableClassName,           -- mentioned, ccallish
 134
 135         -- ClassOps
 136         fromIntegerName,
 137         negateName,
 138         geName,
 139         minusName,
 140         enumFromName,
 141         enumFromThenName,
 142         enumFromToName,
 143         enumFromThenToName,
 144         fromEnumName,
 145         toEnumName,
 146         eqName,
 147         thenMName,
 148         returnMName,
 149         failMName,
 150         fromRationalName,
 151
 152         -- not class methods, but overloaded (for parallel arrays)
 153         enumFromToPName,
 154         enumFromThenToPName,
 155
 156         deRefStablePtrName,
 157         newStablePtrName,
 158         bindIOName,
 159         returnIOName,
 160         failIOName,
 161
 162         -- Strings and lists
 163         mapName,
 164         appendName,
 165         unpackCStringName,
 166         unpackCStringAppendName,
 167         unpackCStringFoldrName,
 168         unpackCStringUtf8Name,
 169
 170         -- List operations
 171         concatName,
 172         filterName,
 173         zipName,
 174         foldrName,
 175         buildName,
 176         augmentName,
 177
 178         -- Parallel array operations
 179         nullPName,
 180         lengthPName,
 181         replicatePName,
 182         mapPName,
 183         filterPName,
 184         zipPName,
 185         crossPName,
 186         indexPName,
 187         toPName,
 188         bpermutePName,
 189         bpermuteDftPName,
 190         indexOfPName,
 191
 192         -- FFI primitive types that are not wired-in.
 193         int8TyConName,
 194         int16TyConName,
 195         int32TyConName,
 196         int64TyConName,
 197         word8TyConName,
 198         word16TyConName,
 199         word32TyConName,
 200         word64TyConName,
 201
 202         -- Others
 203         unsafeCoerceName,
 204         otherwiseIdName,
 205         plusIntegerName,
 206         timesIntegerName,
 207         eqStringName,
 208         assertName,
 209         runSTRepName,
 210         printName,
 211         splitName, fstName, sndName,    -- Used by splittery
 212
 213         -- Others (needed for flattening and not mentioned before)
 214         andName,
 215         orName,
 216         eqCharName,
 217         eqIntName,
 218         eqFloatName,
 219         eqDoubleName,
 220         neqCharName,
 221         neqIntName,
 222         neqFloatName,
 223         neqDoubleName
 224     ]
 225 \end{code}
 226
 227
 228 %************************************************************************
 229 %*                                                                      *
 230 \subsection{Module names}
 231 %*                                                                      *
 232 %************************************************************************
 233
 234 \begin{code}
 235 pRELUDE_Name      = mkModuleName "Prelude"
 236 pREL_GHC_Name     = mkModuleName "PrelGHC"         -- Primitive types and values
 237 pREL_BASE_Name    = mkModuleName "PrelBase"
 238 pREL_ENUM_Name    = mkModuleName "PrelEnum"
 239 pREL_SHOW_Name    = mkModuleName "PrelShow"
 240 pREL_READ_Name    = mkModuleName "PrelRead"
 241 pREL_NUM_Name     = mkModuleName "PrelNum"
 242 pREL_LIST_Name    = mkModuleName "PrelList"
 243 pREL_PARR_Name    = mkModuleName "PrelPArr"
 244 pREL_TUP_Name     = mkModuleName "PrelTup"
 245 pREL_PACK_Name    = mkModuleName "PrelPack"
 246 pREL_CONC_Name    = mkModuleName "PrelConc"
 247 pREL_IO_BASE_Name = mkModuleName "PrelIOBase"
 248 pREL_IO_Name      = mkModuleName "PrelIO"
 249 pREL_ST_Name      = mkModuleName "PrelST"
 250 pREL_ARR_Name     = mkModuleName "PrelArr"
 251 pREL_BYTEARR_Name = mkModuleName "PrelByteArr"
 252 pREL_FOREIGN_Name = mkModuleName "PrelForeign"
 253 pREL_STABLE_Name  = mkModuleName "PrelStable"
 254 pREL_SPLIT_Name   = mkModuleName "PrelSplit"
 255 pREL_ADDR_Name    = mkModuleName "PrelAddr"
 256 pREL_PTR_Name     = mkModuleName "PrelPtr"
 257 pREL_ERR_Name     = mkModuleName "PrelErr"
 258 pREL_REAL_Name    = mkModuleName "PrelReal"
 259 pREL_FLOAT_Name   = mkModuleName "PrelFloat"
 260 pREL_TOP_HANDLER_Name = mkModuleName "PrelTopHandler"
 261
 262 mAIN_Name         = mkModuleName "Main"
 263 pREL_INT_Name     = mkModuleName "PrelInt"
 264 pREL_WORD_Name    = mkModuleName "PrelWord"
 265
 266 fOREIGNOBJ_Name   = mkModuleName "ForeignObj"
 267 aDDR_Name         = mkModuleName "Addr"
 268
 269 gLA_EXTS_Name   = mkModuleName "GlaExts"
 270
 271 pREL_GHC        = mkPrelModule pREL_GHC_Name
 272 pREL_BASE       = mkPrelModule pREL_BASE_Name
 273 pREL_ADDR       = mkPrelModule pREL_ADDR_Name
 274 pREL_PTR        = mkPrelModule pREL_PTR_Name
 275 pREL_STABLE     = mkPrelModule pREL_STABLE_Name
 276 pREL_IO_BASE    = mkPrelModule pREL_IO_BASE_Name
 277 pREL_PACK       = mkPrelModule pREL_PACK_Name
 278 pREL_ERR        = mkPrelModule pREL_ERR_Name
 279 pREL_NUM        = mkPrelModule pREL_NUM_Name
 280 pREL_REAL       = mkPrelModule pREL_REAL_Name
 281 pREL_FLOAT      = mkPrelModule pREL_FLOAT_Name
 282 pRELUDE         = mkPrelModule pRELUDE_Name
 283
 284 iNTERACTIVE     = mkHomeModule (mkModuleName "$Interactive")
 285 \end{code}
 286
 287 %************************************************************************
 288 %*                                                                      *
 289 \subsection{Constructing the names of tuples
 290 %*                                                                      *
 291 %************************************************************************
 292
 293 \begin{code}
 294 mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS)
 295
 296 mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()"))
 297 mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???"
 298 mkTupNameStr Boxed 2 = (pREL_TUP_Name, _PK_ "(,)")   -- not strictly necessary
 299 mkTupNameStr Boxed 3 = (pREL_TUP_Name, _PK_ "(,,)")  -- ditto
 300 mkTupNameStr Boxed 4 = (pREL_TUP_Name, _PK_ "(,,,)") -- ditto
 301 mkTupNameStr Boxed n = (pREL_TUP_Name, _PK_ ("(" ++ nOfThem (n-1) ',' ++ ")"))
 302
 303 mkTupNameStr Unboxed 0 = panic "Name.mkUbxTupNameStr: 0 ???"
 304 mkTupNameStr Unboxed 1 = (pREL_GHC_Name, _PK_ "(# #)") -- 1 and 0 both make sense!!!
 305 mkTupNameStr Unboxed 2 = (pREL_GHC_Name, _PK_ "(#,#)")
 306 mkTupNameStr Unboxed 3 = (pREL_GHC_Name, _PK_ "(#,,#)")
 307 mkTupNameStr Unboxed 4 = (pREL_GHC_Name, _PK_ "(#,,,#)")
 308 mkTupNameStr Unboxed n = (pREL_GHC_Name, _PK_ ("(#" ++ nOfThem (n-1) ',' ++ "#)"))
 309
 310 mkTupConRdrName :: NameSpace -> Boxity -> Arity -> RdrName
 311 mkTupConRdrName space boxity arity   = case mkTupNameStr boxity arity of
 312                                           (mod, occ) -> mkOrig space mod occ
 313 \end{code}
 314
 315
 316 %************************************************************************
 317 %*                                                                      *
 318 \subsection{Unqualified RdrNames}
 319 %*                                                                      *
 320 %************************************************************************
 321
 322 \begin{code}
 323 main_RDR_Unqual :: RdrName
 324 main_RDR_Unqual = mkUnqual varName SLIT("main")
 325 -- Don't get a RdrName from PrelNames.mainName, because nameRdrName
 326 -- gets an Orig RdrName, and we want a Qual or Unqual one.  An Unqual
 327 -- one will do fine.
 328 \end{code}
 329
 330
 331 %************************************************************************
 332 %*                                                                      *
 333 \subsection{Commonly-used RdrNames}
 334 %*                                                                      *
 335 %************************************************************************
 336
 337 Many of these Names are not really "built in", but some parts of the
 338 compiler (notably the deriving mechanism) need to mention their names,
 339 and it's convenient to write them all down in one place.
 340
 341 \begin{code}
 342 dollarMainName = varQual mAIN_Name SLIT("$main") dollarMainKey
 343 runMainName    = varQual pREL_TOP_HANDLER_Name SLIT("runMain") runMainKey
 344
 345 -- Stuff from PrelGHC
 346 usOnceTyConName  = kindQual SLIT(".") usOnceTyConKey
 347 usManyTyConName  = kindQual SLIT("!") usManyTyConKey
 348 superKindName    = kindQual SLIT("KX") kindConKey
 349 superBoxityName  = kindQual SLIT("BX") boxityConKey
 350 liftedConName    = kindQual SLIT("*") liftedConKey
 351 unliftedConName  = kindQual SLIT("#") unliftedConKey
 352 openKindConName  = kindQual SLIT("?") anyBoxConKey
 353 usageKindConName = kindQual SLIT("$") usageConKey
 354 typeConName      = kindQual SLIT("Type") typeConKey
 355
 356 funTyConName                  = tcQual  pREL_GHC_Name SLIT("(->)")  funTyConKey
 357 charPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Char#") charPrimTyConKey
 358 intPrimTyConName              = tcQual  pREL_GHC_Name SLIT("Int#") intPrimTyConKey
 359 int32PrimTyConName            = tcQual  pREL_GHC_Name SLIT("Int32#") int32PrimTyConKey
 360 int64PrimTyConName            = tcQual  pREL_GHC_Name SLIT("Int64#") int64PrimTyConKey
 361 wordPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Word#") wordPrimTyConKey
 362 word32PrimTyConName           = tcQual  pREL_GHC_Name SLIT("Word32#") word32PrimTyConKey
 363 word64PrimTyConName           = tcQual  pREL_GHC_Name SLIT("Word64#") word64PrimTyConKey
 364 addrPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Addr#") addrPrimTyConKey
 365 floatPrimTyConName            = tcQual  pREL_GHC_Name SLIT("Float#") floatPrimTyConKey
 366 doublePrimTyConName           = tcQual  pREL_GHC_Name SLIT("Double#") doublePrimTyConKey
 367 statePrimTyConName            = tcQual  pREL_GHC_Name SLIT("State#") statePrimTyConKey
 368 realWorldTyConName            = tcQual  pREL_GHC_Name SLIT("RealWorld") realWorldTyConKey
 369 arrayPrimTyConName            = tcQual  pREL_GHC_Name SLIT("Array#") arrayPrimTyConKey
 370 byteArrayPrimTyConName        = tcQual  pREL_GHC_Name SLIT("ByteArray#") byteArrayPrimTyConKey
 371 mutableArrayPrimTyConName     = tcQual  pREL_GHC_Name SLIT("MutableArray#") mutableArrayPrimTyConKey
 372 mutableByteArrayPrimTyConName = tcQual  pREL_GHC_Name SLIT("MutableByteArray#") mutableByteArrayPrimTyConKey
 373 mutVarPrimTyConName           = tcQual  pREL_GHC_Name SLIT("MutVar#") mutVarPrimTyConKey
 374 mVarPrimTyConName             = tcQual  pREL_GHC_Name SLIT("MVar#") mVarPrimTyConKey
 375 stablePtrPrimTyConName        = tcQual  pREL_GHC_Name SLIT("StablePtr#") stablePtrPrimTyConKey
 376 stableNamePrimTyConName       = tcQual  pREL_GHC_Name SLIT("StableName#") stableNamePrimTyConKey
 377 foreignObjPrimTyConName       = tcQual  pREL_GHC_Name SLIT("ForeignObj#") foreignObjPrimTyConKey
 378 bcoPrimTyConName              = tcQual  pREL_GHC_Name SLIT("BCO#") bcoPrimTyConKey
 379 weakPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Weak#") weakPrimTyConKey
 380 threadIdPrimTyConName         = tcQual  pREL_GHC_Name SLIT("ThreadId#") threadIdPrimTyConKey
 381 cCallableClassName            = clsQual pREL_GHC_Name SLIT("CCallable") cCallableClassKey
 382 cReturnableClassName          = clsQual pREL_GHC_Name SLIT("CReturnable") cReturnableClassKey
 383
 384 -- PrelBase data types and constructors
 385 charTyConName     = tcQual   pREL_BASE_Name SLIT("Char") charTyConKey
 386 charDataConName   = dataQual pREL_BASE_Name SLIT("C#") charDataConKey
 387 intTyConName      = tcQual   pREL_BASE_Name SLIT("Int") intTyConKey
 388 intDataConName    = dataQual pREL_BASE_Name SLIT("I#") intDataConKey
 389 orderingTyConName = tcQual   pREL_BASE_Name SLIT("Ordering") orderingTyConKey
 390 boolTyConName     = tcQual   pREL_BASE_Name SLIT("Bool") boolTyConKey
 391 falseDataConName  = dataQual pREL_BASE_Name SLIT("False") falseDataConKey
 392 trueDataConName   = dataQual pREL_BASE_Name SLIT("True") trueDataConKey
 393 listTyConName     = tcQual   pREL_BASE_Name SLIT("[]") listTyConKey
 394 nilDataConName    = dataQual pREL_BASE_Name SLIT("[]") nilDataConKey
 395 consDataConName   = dataQual pREL_BASE_Name SLIT(":") consDataConKey
 396
 397 -- PrelTup
 398 fstName           = varQual pREL_TUP_Name SLIT("fst") fstIdKey
 399 sndName           = varQual pREL_TUP_Name SLIT("snd") sndIdKey
 400
 401 -- Generics
 402 crossTyConName     = tcQual   pREL_BASE_Name SLIT(":*:") crossTyConKey
 403 crossDataConName   = dataQual pREL_BASE_Name SLIT(":*:") crossDataConKey
 404 plusTyConName      = tcQual   pREL_BASE_Name SLIT(":+:") plusTyConKey
 405 inlDataConName     = dataQual pREL_BASE_Name SLIT("Inl") inlDataConKey
 406 inrDataConName     = dataQual pREL_BASE_Name SLIT("Inr") inrDataConKey
 407 genUnitTyConName   = tcQual   pREL_BASE_Name SLIT("Unit") genUnitTyConKey
 408 genUnitDataConName = dataQual pREL_BASE_Name SLIT("Unit") genUnitDataConKey
 409
 410 -- Random PrelBase functions
 411 unsafeCoerceName  = varQual pREL_BASE_Name SLIT("unsafeCoerce")
 412                                                              unsafeCoerceIdKey
 413 otherwiseIdName   = varQual pREL_BASE_Name SLIT("otherwise") otherwiseIdKey
 414 appendName        = varQual pREL_BASE_Name SLIT("++")        appendIdKey
 415 foldrName         = varQual pREL_BASE_Name SLIT("foldr")     foldrIdKey
 416 mapName           = varQual pREL_BASE_Name SLIT("map")       mapIdKey
 417 buildName         = varQual pREL_BASE_Name SLIT("build")     buildIdKey
 418 augmentName       = varQual pREL_BASE_Name SLIT("augment")   augmentIdKey
 419 eqStringName      = varQual pREL_BASE_Name SLIT("eqString")  eqStringIdKey
 420 andName           = varQual pREL_BASE_Name SLIT("&&")        andIdKey
 421 orName            = varQual pREL_BASE_Name SLIT("||")        orIdKey
 422 eqCharName        = varQual pREL_GHC_Name  SLIT("eqChar#")   eqCharIdKey
 423 eqIntName         = varQual pREL_GHC_Name  SLIT("==#")       eqIntIdKey
 424 eqFloatName       = varQual pREL_GHC_Name  SLIT("eqFloat#")  eqFloatIdKey
 425 eqDoubleName      = varQual pREL_GHC_Name  SLIT("==##")      eqDoubleIdKey
 426 neqCharName       = varQual pREL_GHC_Name  SLIT("neqChar#")  neqCharIdKey
 427 neqIntName        = varQual pREL_GHC_Name  SLIT("/=#")       neqIntIdKey
 428 neqFloatName      = varQual pREL_GHC_Name  SLIT("neqFloat#") neqFloatIdKey
 429 neqDoubleName     = varQual pREL_GHC_Name  SLIT("/=##")      neqDoubleIdKey
 430
 431 -- Strings
 432 unpackCStringName       = varQual pREL_BASE_Name SLIT("unpackCString#") unpackCStringIdKey
 433 unpackCStringAppendName = varQual pREL_BASE_Name SLIT("unpackAppendCString#") unpackCStringAppendIdKey
 434 unpackCStringFoldrName  = varQual pREL_BASE_Name SLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
 435 unpackCStringUtf8Name   = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
 436
 437 -- Classes Eq and Ord
 438 eqClassName       = clsQual pREL_BASE_Name SLIT("Eq") eqClassKey
 439 ordClassName      = clsQual pREL_BASE_Name SLIT("Ord") ordClassKey
 440 eqName            = varQual  pREL_BASE_Name SLIT("==") eqClassOpKey
 441 geName            = varQual  pREL_BASE_Name SLIT(">=") geClassOpKey
 442
 443 -- Class Monad
 444 monadClassName     = clsQual pREL_BASE_Name SLIT("Monad") monadClassKey
 445 monadPlusClassName = clsQual pREL_BASE_Name SLIT("MonadPlus") monadPlusClassKey
 446 thenMName          = varQual pREL_BASE_Name SLIT(">>=") thenMClassOpKey
 447 returnMName        = varQual pREL_BASE_Name SLIT("return") returnMClassOpKey
 448 failMName          = varQual pREL_BASE_Name SLIT("fail") failMClassOpKey
 449
 450 -- Class Functor
 451 functorClassName  = clsQual pREL_BASE_Name SLIT("Functor") functorClassKey
 452
 453 -- Class Show
 454 showClassName     = clsQual pREL_SHOW_Name SLIT("Show") showClassKey
 455
 456 -- Class Read
 457 readClassName     = clsQual pREL_READ_Name SLIT("Read") readClassKey
 458
 459 -- Module PrelNum
 460 numClassName      = clsQual pREL_NUM_Name SLIT("Num") numClassKey
 461 fromIntegerName   = varQual pREL_NUM_Name SLIT("fromInteger") fromIntegerClassOpKey
 462 minusName         = varQual pREL_NUM_Name SLIT("-") minusClassOpKey
 463 negateName        = varQual pREL_NUM_Name SLIT("negate") negateClassOpKey
 464 plusIntegerName   = varQual pREL_NUM_Name SLIT("plusInteger") plusIntegerIdKey
 465 timesIntegerName  = varQual pREL_NUM_Name SLIT("timesInteger") timesIntegerIdKey
 466 integerTyConName  = tcQual  pREL_NUM_Name SLIT("Integer") integerTyConKey
 467 smallIntegerDataConName = dataQual pREL_NUM_Name SLIT("S#") smallIntegerDataConKey
 468 largeIntegerDataConName = dataQual pREL_NUM_Name SLIT("J#") largeIntegerDataConKey
 469
 470 -- PrelReal types and classes
 471 rationalTyConName   = tcQual   pREL_REAL_Name  SLIT("Rational") rationalTyConKey
 472 ratioTyConName      = tcQual   pREL_REAL_Name  SLIT("Ratio") ratioTyConKey
 473 ratioDataConName    = dataQual pREL_REAL_Name  SLIT(":%") ratioDataConKey
 474 realClassName       = clsQual  pREL_REAL_Name  SLIT("Real") realClassKey
 475 integralClassName   = clsQual  pREL_REAL_Name  SLIT("Integral") integralClassKey
 476 realFracClassName   = clsQual  pREL_REAL_Name  SLIT("RealFrac") realFracClassKey
 477 fractionalClassName = clsQual  pREL_REAL_Name  SLIT("Fractional") fractionalClassKey
 478 fromRationalName    = varQual  pREL_REAL_Name  SLIT("fromRational") fromRationalClassOpKey
 479
 480 -- PrelFloat classes
 481 floatTyConName     = tcQual   pREL_FLOAT_Name SLIT("Float") floatTyConKey
 482 floatDataConName   = dataQual pREL_FLOAT_Name SLIT("F#") floatDataConKey
 483 doubleTyConName    = tcQual   pREL_FLOAT_Name SLIT("Double") doubleTyConKey
 484 doubleDataConName  = dataQual pREL_FLOAT_Name SLIT("D#") doubleDataConKey
 485 floatingClassName  = clsQual  pREL_FLOAT_Name SLIT("Floating") floatingClassKey
 486 realFloatClassName = clsQual  pREL_FLOAT_Name SLIT("RealFloat") realFloatClassKey
 487
 488 -- Class Ix
 489 ixClassName        = clsQual pREL_ARR_Name SLIT("Ix") ixClassKey
 490
 491 -- Class Enum
 492 enumClassName      = clsQual pREL_ENUM_Name SLIT("Enum") enumClassKey
 493 toEnumName         = varQual pREL_ENUM_Name SLIT("toEnum") toEnumClassOpKey
 494 fromEnumName       = varQual pREL_ENUM_Name SLIT("fromEnum") fromEnumClassOpKey
 495 enumFromName       = varQual pREL_ENUM_Name SLIT("enumFrom") enumFromClassOpKey
 496 enumFromToName     = varQual pREL_ENUM_Name SLIT("enumFromTo") enumFromToClassOpKey
 497 enumFromThenName   = varQual pREL_ENUM_Name SLIT("enumFromThen") enumFromThenClassOpKey
 498 enumFromThenToName = varQual pREL_ENUM_Name SLIT("enumFromThenTo") enumFromThenToClassOpKey
 499
 500 -- Overloaded via Class Enum
 501 enumFromToPName    = varQual pREL_PARR_Name SLIT("enumFromToP") enumFromToPIdKey
 502 enumFromThenToPName= varQual pREL_PARR_Name SLIT("enumFromThenToP") enumFromThenToPIdKey
 503
 504 -- Class Bounded
 505 boundedClassName  = clsQual pREL_ENUM_Name SLIT("Bounded") boundedClassKey
 506
 507 -- List functions
 508 concatName        = varQual pREL_LIST_Name SLIT("concat") concatIdKey
 509 filterName        = varQual pREL_LIST_Name SLIT("filter") filterIdKey
 510 zipName           = varQual pREL_LIST_Name SLIT("zip") zipIdKey
 511
 512 -- parallel array types and functions
 513 parrTyConName     = tcQual  pREL_PARR_Name SLIT("[::]")       parrTyConKey
 514 parrDataConName   = dataQual pREL_PARR_Name SLIT("PArr")      parrDataConKey
 515 nullPName         = varQual pREL_PARR_Name SLIT("nullP")      nullPIdKey
 516 lengthPName       = varQual pREL_PARR_Name SLIT("lengthP")    lengthPIdKey
 517 replicatePName    = varQual pREL_PARR_Name SLIT("replicateP") replicatePIdKey
 518 mapPName          = varQual pREL_PARR_Name SLIT("mapP")       mapPIdKey
 519 filterPName       = varQual pREL_PARR_Name SLIT("filterP")    filterPIdKey
 520 zipPName          = varQual pREL_PARR_Name SLIT("zipP")       zipPIdKey
 521 crossPName        = varQual pREL_PARR_Name SLIT("crossP")     crossPIdKey
 522 indexPName        = varQual pREL_PARR_Name SLIT("!:")         indexPIdKey
 523 toPName           = varQual pREL_PARR_Name SLIT("toP")        toPIdKey
 524 bpermutePName     = varQual pREL_PARR_Name SLIT("bpermuteP")  bpermutePIdKey
 525 bpermuteDftPName  = varQual pREL_PARR_Name SLIT("bpermuteDftP")
 526                                                               bpermuteDftPIdKey
 527 indexOfPName      = varQual pREL_PARR_Name SLIT("indexOfP")   indexOfPIdKey
 528
 529 -- IOBase things
 530 ioTyConName       = tcQual   pREL_IO_BASE_Name SLIT("IO") ioTyConKey
 531 ioDataConName     = dataQual pREL_IO_BASE_Name SLIT("IO") ioDataConKey
 532 bindIOName        = varQual  pREL_IO_BASE_Name SLIT("bindIO") bindIOIdKey
 533 returnIOName      = varQual  pREL_IO_BASE_Name SLIT("returnIO") returnIOIdKey
 534 failIOName        = varQual  pREL_IO_BASE_Name SLIT("failIO") failIOIdKey
 535
 536 -- IO things
 537 printName         = varQual pREL_IO_Name SLIT("print") printIdKey
 538
 539 -- Int, Word, and Addr things
 540 int8TyConName     = tcQual pREL_INT_Name  SLIT("Int8") int8TyConKey
 541 int16TyConName    = tcQual pREL_INT_Name  SLIT("Int16") int16TyConKey
 542 int32TyConName    = tcQual pREL_INT_Name  SLIT("Int32") int32TyConKey
 543 int64TyConName    = tcQual pREL_INT_Name  SLIT("Int64") int64TyConKey
 544
 545 word8TyConName    = tcQual pREL_WORD_Name SLIT("Word8")  word8TyConKey
 546 word16TyConName   = tcQual pREL_WORD_Name SLIT("Word16") word16TyConKey
 547 word32TyConName   = tcQual pREL_WORD_Name SLIT("Word32") word32TyConKey
 548 word64TyConName   = tcQual pREL_WORD_Name SLIT("Word64") word64TyConKey
 549
 550 wordTyConName     = tcQual   pREL_WORD_Name SLIT("Word")   wordTyConKey
 551 wordDataConName   = dataQual pREL_WORD_Name SLIT("W#")     wordDataConKey
 552
 553 addrTyConName     = tcQual   aDDR_Name SLIT("Addr") addrTyConKey
 554 addrDataConName   = dataQual aDDR_Name SLIT("A#") addrDataConKey
 555
 556 ptrTyConName      = tcQual   pREL_PTR_Name SLIT("Ptr") ptrTyConKey
 557 ptrDataConName    = dataQual pREL_PTR_Name SLIT("Ptr") ptrDataConKey
 558
 559 funPtrTyConName   = tcQual   pREL_PTR_Name SLIT("FunPtr") funPtrTyConKey
 560 funPtrDataConName = dataQual pREL_PTR_Name SLIT("FunPtr") funPtrDataConKey
 561
 562 -- Byte array types
 563 byteArrayTyConName        = tcQual pREL_BYTEARR_Name  SLIT("ByteArray") byteArrayTyConKey
 564 mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name  SLIT("MutableByteArray") mutableByteArrayTyConKey
 565
 566 -- Foreign objects and weak pointers
 567 foreignObjTyConName   = tcQual   fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjTyConKey
 568 foreignObjDataConName = dataQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjDataConKey
 569 foreignPtrTyConName   = tcQual   pREL_FOREIGN_Name SLIT("ForeignPtr") foreignPtrTyConKey
 570 foreignPtrDataConName = dataQual pREL_FOREIGN_Name SLIT("ForeignPtr") foreignPtrDataConKey
 571 stablePtrTyConName    = tcQual   pREL_STABLE_Name SLIT("StablePtr") stablePtrTyConKey
 572 stablePtrDataConName  = dataQual pREL_STABLE_Name SLIT("StablePtr") stablePtrDataConKey
 573 deRefStablePtrName    = varQual  pREL_STABLE_Name SLIT("deRefStablePtr") deRefStablePtrIdKey
 574 newStablePtrName      = varQual  pREL_STABLE_Name SLIT("newStablePtr") newStablePtrIdKey
 575
 576 errorName          = varQual pREL_ERR_Name SLIT("error") errorIdKey
 577 assertName         = varQual pREL_GHC_Name SLIT("assert") assertIdKey
 578 getTagName         = varQual pREL_GHC_Name SLIT("getTag#") getTagIdKey
 579 runSTRepName       = varQual pREL_ST_Name  SLIT("runSTRep") runSTRepIdKey
 580
 581 -- The "split" Id for splittable implicit parameters
 582 splitName          = varQual pREL_SPLIT_Name SLIT("split") splitIdKey
 583 \end{code}
 584
 585 %************************************************************************
 586 %*                                                                      *
 587 \subsection{Known names}
 588 %*                                                                      *
 589 %************************************************************************
 590
 591 The following names are known to the compiler, but they don't require
 592 pre-assigned keys.  Mostly these names are used in generating deriving
 593 code, which is passed through the renamer anyway.
 594
 595         THEY ARE ALL ORIGINAL NAMES, HOWEVER
 596
 597 \begin{code}
 598 -- Lists and tuples
 599 tupleCon_RDR, tupleTyCon_RDR            :: Int -> RdrName
 600 ubxTupleCon_RDR, ubxTupleTyCon_RDR      :: Int -> RdrName
 601
 602 tupleCon_RDR      = mkTupConRdrName dataName Boxed
 603 tupleTyCon_RDR    = mkTupConRdrName tcName   Boxed
 604 ubxTupleCon_RDR   = mkTupConRdrName dataName Unboxed
 605 ubxTupleTyCon_RDR = mkTupConRdrName tcName   Unboxed
 606
 607 unitCon_RDR       = dataQual_RDR pREL_BASE_Name SLIT("()")
 608 unitTyCon_RDR     = tcQual_RDR   pREL_BASE_Name SLIT("()")
 609
 610 and_RDR            = varQual_RDR  pREL_BASE_Name SLIT("&&")
 611 not_RDR            = varQual_RDR  pREL_BASE_Name SLIT("not")
 612 compose_RDR        = varQual_RDR  pREL_BASE_Name SLIT(".")
 613 ne_RDR             = varQual_RDR  pREL_BASE_Name SLIT("/=")
 614 le_RDR             = varQual_RDR  pREL_BASE_Name SLIT("<=")
 615 lt_RDR             = varQual_RDR  pREL_BASE_Name SLIT("<")
 616 gt_RDR             = varQual_RDR  pREL_BASE_Name SLIT(">")
 617 ltTag_RDR          = dataQual_RDR pREL_BASE_Name SLIT("LT")
 618 eqTag_RDR          = dataQual_RDR pREL_BASE_Name SLIT("EQ")
 619 gtTag_RDR          = dataQual_RDR pREL_BASE_Name SLIT("GT")
 620 max_RDR            = varQual_RDR  pREL_BASE_Name SLIT("max")
 621 min_RDR            = varQual_RDR  pREL_BASE_Name SLIT("min")
 622 compare_RDR        = varQual_RDR  pREL_BASE_Name SLIT("compare")
 623 showList_RDR       = varQual_RDR  pREL_SHOW_Name SLIT("showList")
 624 showList___RDR     = varQual_RDR  pREL_SHOW_Name SLIT("showList__")
 625 showsPrec_RDR      = varQual_RDR  pREL_SHOW_Name SLIT("showsPrec")
 626 showSpace_RDR      = varQual_RDR  pREL_SHOW_Name SLIT("showSpace")
 627 showString_RDR     = varQual_RDR  pREL_SHOW_Name SLIT("showString")
 628 showParen_RDR      = varQual_RDR  pREL_SHOW_Name SLIT("showParen")
 629 readsPrec_RDR      = varQual_RDR  pREL_READ_Name SLIT("readsPrec")
 630 readList_RDR       = varQual_RDR  pREL_READ_Name SLIT("readList")
 631 readParen_RDR      = varQual_RDR  pREL_READ_Name SLIT("readParen")
 632 lex_RDR            = varQual_RDR  pREL_READ_Name SLIT("lex")
 633 readList___RDR     = varQual_RDR  pREL_READ_Name SLIT("readList__")
 634 times_RDR          = varQual_RDR  pREL_NUM_Name SLIT("*")
 635 plus_RDR           = varQual_RDR  pREL_NUM_Name SLIT("+")
 636 negate_RDR         = varQual_RDR  pREL_NUM_Name SLIT("negate")
 637 range_RDR          = varQual_RDR  pREL_ARR_Name SLIT("range")
 638 index_RDR          = varQual_RDR  pREL_ARR_Name SLIT("index")
 639 inRange_RDR        = varQual_RDR  pREL_ARR_Name SLIT("inRange")
 640 succ_RDR           = varQual_RDR  pREL_ENUM_Name SLIT("succ")
 641 pred_RDR           = varQual_RDR  pREL_ENUM_Name SLIT("pred")
 642 minBound_RDR       = varQual_RDR  pREL_ENUM_Name SLIT("minBound")
 643 maxBound_RDR       = varQual_RDR  pREL_ENUM_Name SLIT("maxBound")
 644 assertErr_RDR      = varQual_RDR  pREL_ERR_Name SLIT("assertError")
 645 \end{code}
 646
 647 These RDR names also have known keys, so we need to get back the RDR names to
 648 populate the occurrence list above.
 649
 650 \begin{code}
 651 funTyCon_RDR            = nameRdrName funTyConName
 652 nilCon_RDR              = nameRdrName nilDataConName
 653 listTyCon_RDR           = nameRdrName listTyConName
 654 parrTyCon_RDR           = nameRdrName parrTyConName
 655 ioTyCon_RDR             = nameRdrName ioTyConName
 656 intTyCon_RDR            = nameRdrName intTyConName
 657 eq_RDR                  = nameRdrName eqName
 658 ge_RDR                  = nameRdrName geName
 659 numClass_RDR            = nameRdrName numClassName
 660 ordClass_RDR            = nameRdrName ordClassName
 661 map_RDR                 = nameRdrName mapName
 662 append_RDR              = nameRdrName appendName
 663 foldr_RDR               = nameRdrName foldrName
 664 build_RDR               = nameRdrName buildName
 665 enumFromTo_RDR          = nameRdrName enumFromToName
 666 returnM_RDR             = nameRdrName returnMName
 667 thenM_RDR               = nameRdrName thenMName
 668 failM_RDR               = nameRdrName failMName
 669 false_RDR               = nameRdrName falseDataConName
 670 true_RDR                = nameRdrName trueDataConName
 671 error_RDR               = nameRdrName errorName
 672 getTag_RDR              = nameRdrName getTagName
 673 fromEnum_RDR            = nameRdrName fromEnumName
 674 toEnum_RDR              = nameRdrName toEnumName
 675 enumFrom_RDR            = nameRdrName enumFromName
 676 mkInt_RDR               = nameRdrName intDataConName
 677 enumFromThen_RDR        = nameRdrName enumFromThenName
 678 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 679 ratioDataCon_RDR        = nameRdrName ratioDataConName
 680 plusInteger_RDR         = nameRdrName plusIntegerName
 681 timesInteger_RDR        = nameRdrName timesIntegerName
 682 enumClass_RDR           = nameRdrName enumClassName
 683 monadClass_RDR          = nameRdrName monadClassName
 684 ioDataCon_RDR           = nameRdrName ioDataConName
 685 cCallableClass_RDR      = nameRdrName cCallableClassName
 686 cReturnableClass_RDR    = nameRdrName cReturnableClassName
 687 eqClass_RDR             = nameRdrName eqClassName
 688 eqString_RDR            = nameRdrName eqStringName
 689 unpackCString_RDR       = nameRdrName unpackCStringName
 690 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 691 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 692 deRefStablePtr_RDR      = nameRdrName deRefStablePtrName
 693 newStablePtr_RDR        = nameRdrName newStablePtrName
 694 bindIO_RDR              = nameRdrName bindIOName
 695 returnIO_RDR            = nameRdrName returnIOName
 696 fromInteger_RDR         = nameRdrName fromIntegerName
 697 fromRational_RDR        = nameRdrName fromRationalName
 698 minus_RDR               = nameRdrName minusName
 699 \end{code}
 700
 701 %************************************************************************
 702 %*                                                                      *
 703 \subsection{Local helpers}
 704 %*                                                                      *
 705 %************************************************************************
 706
 707 All these are original names; hence mkOrig
 708
 709 \begin{code}
 710 varQual  mod str uq = mkKnownKeyGlobal (varQual_RDR  mod str) uq
 711 dataQual mod str uq = mkKnownKeyGlobal (dataQual_RDR mod str) uq
 712 tcQual   mod str uq = mkKnownKeyGlobal (tcQual_RDR   mod str) uq
 713 clsQual  mod str uq = mkKnownKeyGlobal (clsQual_RDR  mod str) uq
 714
 715 kindQual str uq = mkLocalName uq (mkKindOccFS tcName str) builtinSrcLoc
 716         -- Kinds are not z-encoded in interface file, hence mkKindOccFS
 717         -- And they don't come from any particular module; indeed we always
 718         -- want to print them unqualified.  Hence the LocalName
 719
 720 varQual_RDR  mod str = mkOrig varName  mod str
 721 tcQual_RDR   mod str = mkOrig tcName   mod str
 722 clsQual_RDR  mod str = mkOrig clsName  mod str
 723 dataQual_RDR mod str = mkOrig dataName mod str
 724 \end{code}
 725
 726 %************************************************************************
 727 %*                                                                      *
 728 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 729 %*                                                                      *
 730 %************************************************************************
 731
 732 \begin{code}
 733 boundedClassKey         = mkPreludeClassUnique 1
 734 enumClassKey            = mkPreludeClassUnique 2
 735 eqClassKey              = mkPreludeClassUnique 3
 736 floatingClassKey        = mkPreludeClassUnique 5
 737 fractionalClassKey      = mkPreludeClassUnique 6
 738 integralClassKey        = mkPreludeClassUnique 7
 739 monadClassKey           = mkPreludeClassUnique 8
 740 monadPlusClassKey       = mkPreludeClassUnique 9
 741 functorClassKey         = mkPreludeClassUnique 10
 742 numClassKey             = mkPreludeClassUnique 11
 743 ordClassKey             = mkPreludeClassUnique 12
 744 readClassKey            = mkPreludeClassUnique 13
 745 realClassKey            = mkPreludeClassUnique 14
 746 realFloatClassKey       = mkPreludeClassUnique 15
 747 realFracClassKey        = mkPreludeClassUnique 16
 748 showClassKey            = mkPreludeClassUnique 17
 749
 750 cCallableClassKey       = mkPreludeClassUnique 18
 751 cReturnableClassKey     = mkPreludeClassUnique 19
 752
 753 ixClassKey              = mkPreludeClassUnique 20
 754 \end{code}
 755
 756 %************************************************************************
 757 %*                                                                      *
 758 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 759 %*                                                                      *
 760 %************************************************************************
 761
 762 \begin{code}
 763 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 764 addrTyConKey                            = mkPreludeTyConUnique  2
 765 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 766 boolTyConKey                            = mkPreludeTyConUnique  4
 767 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 768 charPrimTyConKey                        = mkPreludeTyConUnique  7
 769 charTyConKey                            = mkPreludeTyConUnique  8
 770 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 771 doubleTyConKey                          = mkPreludeTyConUnique 10
 772 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 773 floatTyConKey                           = mkPreludeTyConUnique 12
 774 funTyConKey                             = mkPreludeTyConUnique 13
 775 intPrimTyConKey                         = mkPreludeTyConUnique 14
 776 intTyConKey                             = mkPreludeTyConUnique 15
 777 int8TyConKey                            = mkPreludeTyConUnique 16
 778 int16TyConKey                           = mkPreludeTyConUnique 17
 779 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 780 int32TyConKey                           = mkPreludeTyConUnique 19
 781 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 782 int64TyConKey                           = mkPreludeTyConUnique 21
 783 integerTyConKey                         = mkPreludeTyConUnique 22
 784 listTyConKey                            = mkPreludeTyConUnique 23
 785 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 786 foreignObjTyConKey                      = mkPreludeTyConUnique 25
 787 foreignPtrTyConKey                      = mkPreludeTyConUnique 26
 788 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 789 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 790 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 791 orderingTyConKey                        = mkPreludeTyConUnique 30
 792 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 793 ratioTyConKey                           = mkPreludeTyConUnique 32
 794 rationalTyConKey                        = mkPreludeTyConUnique 33
 795 realWorldTyConKey                       = mkPreludeTyConUnique 34
 796 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 797 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 798 statePrimTyConKey                       = mkPreludeTyConUnique 50
 799 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 800 stableNameTyConKey                      = mkPreludeTyConUnique 52
 801 mutableByteArrayTyConKey                = mkPreludeTyConUnique 53
 802 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 803 ioTyConKey                              = mkPreludeTyConUnique 56
 804 byteArrayTyConKey                       = mkPreludeTyConUnique 57
 805 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 806 wordTyConKey                            = mkPreludeTyConUnique 59
 807 word8TyConKey                           = mkPreludeTyConUnique 60
 808 word16TyConKey                          = mkPreludeTyConUnique 61
 809 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 810 word32TyConKey                          = mkPreludeTyConUnique 63
 811 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 812 word64TyConKey                          = mkPreludeTyConUnique 65
 813 liftedConKey                            = mkPreludeTyConUnique 66
 814 unliftedConKey                          = mkPreludeTyConUnique 67
 815 anyBoxConKey                            = mkPreludeTyConUnique 68
 816 kindConKey                              = mkPreludeTyConUnique 69
 817 boxityConKey                            = mkPreludeTyConUnique 70
 818 typeConKey                              = mkPreludeTyConUnique 71
 819 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 820 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 821 ptrTyConKey                             = mkPreludeTyConUnique 74
 822 funPtrTyConKey                          = mkPreludeTyConUnique 75
 823
 824 -- Usage type constructors
 825 usageConKey                             = mkPreludeTyConUnique 76
 826 usOnceTyConKey                          = mkPreludeTyConUnique 77
 827 usManyTyConKey                          = mkPreludeTyConUnique 78
 828
 829 -- Generic Type Constructors
 830 crossTyConKey                           = mkPreludeTyConUnique 79
 831 plusTyConKey                            = mkPreludeTyConUnique 80
 832 genUnitTyConKey                         = mkPreludeTyConUnique 81
 833
 834 -- Parallel array type constructor
 835 parrTyConKey                            = mkPreludeTyConUnique 82
 836
 837 unitTyConKey = mkTupleTyConUnique Boxed 0
 838 \end{code}
 839
 840 %************************************************************************
 841 %*                                                                      *
 842 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 843 %*                                                                      *
 844 %************************************************************************
 845
 846 \begin{code}
 847 addrDataConKey                          = mkPreludeDataConUnique  0
 848 charDataConKey                          = mkPreludeDataConUnique  1
 849 consDataConKey                          = mkPreludeDataConUnique  2
 850 doubleDataConKey                        = mkPreludeDataConUnique  3
 851 falseDataConKey                         = mkPreludeDataConUnique  4
 852 floatDataConKey                         = mkPreludeDataConUnique  5
 853 intDataConKey                           = mkPreludeDataConUnique  6
 854 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 855 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 856 foreignObjDataConKey                    = mkPreludeDataConUnique  9
 857 foreignPtrDataConKey                    = mkPreludeDataConUnique 10
 858 nilDataConKey                           = mkPreludeDataConUnique 11
 859 ratioDataConKey                         = mkPreludeDataConUnique 12
 860 stablePtrDataConKey                     = mkPreludeDataConUnique 13
 861 stableNameDataConKey                    = mkPreludeDataConUnique 14
 862 trueDataConKey                          = mkPreludeDataConUnique 15
 863 wordDataConKey                          = mkPreludeDataConUnique 16
 864 ioDataConKey                            = mkPreludeDataConUnique 17
 865 ptrDataConKey                           = mkPreludeDataConUnique 18
 866 funPtrDataConKey                        = mkPreludeDataConUnique 19
 867
 868 -- Generic data constructors
 869 crossDataConKey                         = mkPreludeDataConUnique 20
 870 inlDataConKey                           = mkPreludeDataConUnique 21
 871 inrDataConKey                           = mkPreludeDataConUnique 22
 872 genUnitDataConKey                       = mkPreludeDataConUnique 23
 873
 874 -- Data constructor for parallel arrays
 875 parrDataConKey                          = mkPreludeDataConUnique 24
 876 \end{code}
 877
 878 %************************************************************************
 879 %*                                                                      *
 880 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 881 %*                                                                      *
 882 %************************************************************************
 883
 884 \begin{code}
 885 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 886 appendIdKey                   = mkPreludeMiscIdUnique  2
 887 augmentIdKey                  = mkPreludeMiscIdUnique  3
 888 buildIdKey                    = mkPreludeMiscIdUnique  4
 889 errorIdKey                    = mkPreludeMiscIdUnique  5
 890 foldlIdKey                    = mkPreludeMiscIdUnique  6
 891 foldrIdKey                    = mkPreludeMiscIdUnique  7
 892 recSelErrIdKey                = mkPreludeMiscIdUnique  8
 893 integerMinusOneIdKey          = mkPreludeMiscIdUnique  9
 894 integerPlusOneIdKey           = mkPreludeMiscIdUnique 10
 895 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 11
 896 integerZeroIdKey              = mkPreludeMiscIdUnique 12
 897 int2IntegerIdKey              = mkPreludeMiscIdUnique 13
 898 seqIdKey                      = mkPreludeMiscIdUnique 14
 899 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 15
 900 eqStringIdKey                 = mkPreludeMiscIdUnique 16
 901 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 17
 902 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
 903 errorCStringIdKey             = mkPreludeMiscIdUnique 19
 904 parErrorIdKey                 = mkPreludeMiscIdUnique 20
 905 parIdKey                      = mkPreludeMiscIdUnique 21
 906 patErrorIdKey                 = mkPreludeMiscIdUnique 22
 907 realWorldPrimIdKey            = mkPreludeMiscIdUnique 23
 908 recConErrorIdKey              = mkPreludeMiscIdUnique 24
 909 recUpdErrorIdKey              = mkPreludeMiscIdUnique 25
 910 traceIdKey                    = mkPreludeMiscIdUnique 26
 911 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 27
 912 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 28
 913 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 29
 914 unpackCStringIdKey            = mkPreludeMiscIdUnique 30
 915 ushowListIdKey                = mkPreludeMiscIdUnique 31
 916 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 917 concatIdKey                   = mkPreludeMiscIdUnique 33
 918 filterIdKey                   = mkPreludeMiscIdUnique 34
 919 zipIdKey                      = mkPreludeMiscIdUnique 35
 920 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 921 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 922 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 923 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 924 getTagIdKey                   = mkPreludeMiscIdUnique 40
 925 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 926 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 927 printIdKey                    = mkPreludeMiscIdUnique 43
 928 failIOIdKey                   = mkPreludeMiscIdUnique 44
 929 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
 930 voidArgIdKey                  = mkPreludeMiscIdUnique 47
 931 splitIdKey                    = mkPreludeMiscIdUnique 48
 932 fstIdKey                      = mkPreludeMiscIdUnique 49
 933 sndIdKey                      = mkPreludeMiscIdUnique 50
 934 otherwiseIdKey                = mkPreludeMiscIdUnique 51
 935 mapIdKey                      = mkPreludeMiscIdUnique 52
 936 assertIdKey                   = mkPreludeMiscIdUnique 53
 937 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
 938
 939 dollarMainKey                 = mkPreludeMiscIdUnique 55
 940 runMainKey                    = mkPreludeMiscIdUnique 56
 941
 942 andIdKey                      = mkPreludeMiscIdUnique 57
 943 orIdKey                       = mkPreludeMiscIdUnique 58
 944 eqCharIdKey                   = mkPreludeMiscIdUnique 59
 945 eqIntIdKey                    = mkPreludeMiscIdUnique 60
 946 eqFloatIdKey                  = mkPreludeMiscIdUnique 61
 947 eqDoubleIdKey                 = mkPreludeMiscIdUnique 62
 948 neqCharIdKey                  = mkPreludeMiscIdUnique 63
 949 neqIntIdKey                   = mkPreludeMiscIdUnique 64
 950 neqFloatIdKey                 = mkPreludeMiscIdUnique 65
 951 neqDoubleIdKey                = mkPreludeMiscIdUnique 66
 952
 953 -- NB: Currently a gap of four slots
 954
 955 -- Parallel array functions
 956 nullPIdKey                    = mkPreludeMiscIdUnique 70
 957 lengthPIdKey                  = mkPreludeMiscIdUnique 71
 958 replicatePIdKey               = mkPreludeMiscIdUnique 72
 959 mapPIdKey                     = mkPreludeMiscIdUnique 73
 960 filterPIdKey                  = mkPreludeMiscIdUnique 74
 961 zipPIdKey                     = mkPreludeMiscIdUnique 75
 962 crossPIdKey                   = mkPreludeMiscIdUnique 76
 963 indexPIdKey                   = mkPreludeMiscIdUnique 77
 964 toPIdKey                      = mkPreludeMiscIdUnique 78
 965 enumFromToPIdKey              = mkPreludeMiscIdUnique 79
 966 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 80
 967 bpermutePIdKey                = mkPreludeMiscIdUnique 81
 968 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 82
 969 indexOfPIdKey                 = mkPreludeMiscIdUnique 83
 970 \end{code}
 971
 972 Certain class operations from Prelude classes.  They get their own
 973 uniques so we can look them up easily when we want to conjure them up
 974 during type checking.
 975
 976 \begin{code}
 977         -- Just a place holder for  unbound variables  produced by the renamer:
 978 unboundKey                    = mkPreludeMiscIdUnique 101
 979 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
 980 minusClassOpKey               = mkPreludeMiscIdUnique 103
 981 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
 982 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
 983 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
 984 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
 985 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
 986 eqClassOpKey                  = mkPreludeMiscIdUnique 109
 987 geClassOpKey                  = mkPreludeMiscIdUnique 110
 988 negateClassOpKey              = mkPreludeMiscIdUnique 111
 989 failMClassOpKey               = mkPreludeMiscIdUnique 112
 990 thenMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
 991 fromEnumClassOpKey            = mkPreludeMiscIdUnique 115
 992 returnMClassOpKey             = mkPreludeMiscIdUnique 117
 993 toEnumClassOpKey              = mkPreludeMiscIdUnique 119
 994 \end{code}
 995
 996
 997 %************************************************************************
 998 %*                                                                      *
 999 \subsection{Standard groups of types}
1000 %*                                                                      *
1001 %************************************************************************
1002
1003 \begin{code}
1004 numericTyKeys =
1005         [ addrTyConKey
1006         , wordTyConKey
1007         , intTyConKey
1008         , integerTyConKey
1009         , doubleTyConKey
1010         , floatTyConKey
1011         ]
1012
1013         -- Renamer always imports these data decls replete with constructors
1014         -- so that desugarer can always see their constructors.  Ugh!
1015 cCallishTyKeys =
1016         [ addrTyConKey
1017         , wordTyConKey
1018         , byteArrayTyConKey
1019         , mutableByteArrayTyConKey
1020         , foreignObjTyConKey
1021         , foreignPtrTyConKey
1022         , stablePtrTyConKey
1023         , int8TyConKey
1024         , int16TyConKey
1025         , int32TyConKey
1026         , int64TyConKey
1027         , word8TyConKey
1028         , word16TyConKey
1029         , word32TyConKey
1030         , word64TyConKey
1031         ]
1032 \end{code}
1033
1034
1035 %************************************************************************
1036 %*                                                                      *
1037 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1038 %*                                                                      *
1039 %************************************************************************
1040
1041 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1042 (@TcDeriv@).
1043
1044 @derivingOccurrences@ maps a class name to a list of the (qualified)
1045 occurrences that will be mentioned by the derived code for the class
1046 when it is later generated.  We don't need to put in things that are
1047 WiredIn (because they are already mapped to their correct name by the
1048 @NameSupply@.  The class itself, and all its class ops, is already
1049 flagged as an occurrence so we don't need to mention that either.
1050
1051 @derivingOccurrences@ has an item for every derivable class, even if
1052 that item is empty, because we treat lookup failure as indicating that
1053 the class is illegal in a deriving clause.
1054
1055 \begin{code}
1056 derivingOccurrences :: UniqFM [RdrName]
1057 derivingOccurrences = listToUFM deriving_occ_info
1058
1059 derivableClassKeys  = map fst deriving_occ_info
1060
1061 deriving_occ_info
1062   = [ (eqClassKey,      [intTyCon_RDR, and_RDR, not_RDR])
1063     , (ordClassKey,     [intTyCon_RDR, compose_RDR, eqTag_RDR])
1064                                 -- EQ (from Ordering) is needed to force in the constructors
1065                                 -- as well as the type constructor.
1066     , (enumClassKey,    [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
1067                                 -- The last two Enum deps are only used to produce better
1068                                 -- error msgs for derived toEnum methods.
1069     , (boundedClassKey, [intTyCon_RDR])
1070     , (showClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
1071                          showParen_RDR, showSpace_RDR, showList___RDR])
1072     , (readClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
1073                          foldr_RDR, build_RDR,
1074                              -- foldr and build required for list comprehension
1075                              -- KSW 2000-06
1076                          lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
1077                              -- returnM (and the rest of the Monad class decl)
1078                              -- will be forced in as result of depending
1079                              -- on thenM.   -- SOF 1/99
1080     , (ixClassKey,      [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
1081                          foldr_RDR, build_RDR,
1082                              -- foldr and build required for list comprehension used
1083                              -- with single constructor types  -- KSW 2000-06
1084                          returnM_RDR, failM_RDR])
1085                              -- the last two are needed to force returnM, thenM and failM
1086                              -- in before typechecking the list(monad) comprehension
1087                              -- generated for derived Ix instances (range method)
1088                              -- of single constructor types.  -- SOF 8/97
1089     ]
1090         -- intTyCon: Practically any deriving needs Int, either for index calculations,
1091         --              or for taggery.
1092         -- ordClass: really it's the methods that are actually used.
1093         -- numClass: for Int literals
1094 \end{code}
1095
1096
1097 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1098 even though every numeric class has these two as a superclass,
1099 because the list of ambiguous dictionaries hasn't been simplified.
1100
1101 \begin{code}
1102 numericClassKeys =
1103         [ numClassKey
1104         , realClassKey
1105         , integralClassKey
1106         ]
1107         ++ fractionalClassKeys
1108
1109 fractionalClassKeys =
1110         [ fractionalClassKey
1111         , floatingClassKey
1112         , realFracClassKey
1113         , realFloatClassKey
1114         ]
1115
1116         -- the strictness analyser needs to know about numeric types
1117         -- (see SaAbsInt.lhs)
1118 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1119         [ readClassKey
1120         ]
1121
1122 cCallishClassKeys =
1123         [ cCallableClassKey
1124         , cReturnableClassKey
1125         ]
1126
1127 standardClassKeys
1128   = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys
1129     --
1130     -- We have to have "CCallable" and "CReturnable" in the standard
1131     -- classes, so that if you go...
1132     --
1133     --      _ccall_ foo ... 93{-numeric literal-} ...
1134     --
1135     -- ... it can do The Right Thing on the 93.
1136
1137 noDictClassKeys         -- These classes are used only for type annotations;
1138                         -- they are not implemented by dictionaries, ever.
1139   = cCallishClassKeys
1140 \end{code}
1141