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