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