ghc/compiler/prelude/PrelNames.lhs

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