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