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