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