ghc/compiler/prelude/PrelNames.lhs

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