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