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
  15         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
  16         knownKeyRdrNames,
  17         mkTupNameStr, mkTupConRdrName,
  18
  19         ------------------------------------------------------------
  20         -- Prelude modules
  21         pREL_GHC, pREL_BASE, pREL_ADDR, pREL_STABLE,
  22         pREL_IO_BASE, pREL_PACK, pREL_ERR, pREL_NUM, pREL_FLOAT, pREL_REAL,
  23
  24         ------------------------------------------------------------
  25         -- Module names (both Prelude and otherwise)
  26         pREL_GHC_Name, pRELUDE_Name, pREL_MAIN_Name, mAIN_Name,
  27
  28         ------------------------------------------------------------
  29         -- Original RdrNames for a few things
  30         main_RDR,
  31         deRefStablePtr_RDR, makeStablePtr_RDR,
  32         ioTyCon_RDR, ioDataCon_RDR, bindIO_RDR, returnIO_RDR,
  33         unpackCString_RDR, unpackCStringFoldr_RDR, unpackCStringUtf8_RDR,
  34         eqClass_RDR, foldr_RDR, build_RDR,
  35         ccallableClass_RDR, creturnableClass_RDR,
  36         monadClass_RDR, enumClass_RDR, ordClass_RDR,
  37         ratioDataCon_RDR, negate_RDR, assertErr_RDR,
  38         plusInteger_RDR, timesInteger_RDR, eqString_RDR,
  39
  40         -- Plus a whole lot more needed only in TcGenDeriv
  41         eq_RDR, ne_RDR, not_RDR, compare_RDR, ge_RDR, le_RDR, gt_RDR,
  42         ltTag_RDR, eqTag_RDR, gtTag_RDR, getTag_RDR,
  43         and_RDR, true_RDR, false_RDR,
  44         succ_RDR, pred_RDR, toEnum_RDR, fromEnum_RDR,
  45         minBound_RDR, maxBound_RDR,
  46         enumFrom_RDR, enumFromThen_RDR, enumFromTo_RDR, enumFromThenTo_RDR,
  47         map_RDR, append_RDR, compose_RDR,
  48         plus_RDR, times_RDR, mkInt_RDR,
  49         error_RDR,
  50         range_RDR, inRange_RDR, index_RDR,
  51         readList___RDR, readList_RDR, readsPrec_RDR, lex_RDR, readParen_RDR,
  52         showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR, showSpace_RDR, showParen_RDR,
  53
  54         ------------------------------------------------------------
  55         -- Goups of classes and types
  56         needsDataDeclCtxtClassKeys, cCallishClassKeys, noDictClassKeys,
  57         fractionalClassKeys, numericClassKeys, standardClassKeys,
  58         derivingOccurrences,    -- For a given class C, this tells what other
  59         derivableClassKeys,     -- things are needed as a result of a
  60                                 -- deriving(C) clause
  61         numericTyKeys, cCallishTyKeys,
  62
  63         ------------------------------------------------------------
  64         -- Keys
  65         absentErrorIdKey, addrDataConKey, addrPrimTyConKey, addrTyConKey,
  66         appendIdKey, arrayPrimTyConKey, assertIdKey, augmentIdKey,
  67         bcoPrimTyConKey, bindIOIdKey, boolTyConKey, boundedClassKey,
  68         boxedConKey, buildIdKey, byteArrayPrimTyConKey, byteArrayTyConKey,
  69         cCallableClassKey, cReturnableClassKey, charDataConKey,
  70         charPrimTyConKey, charTyConKey, concatIdKey, consDataConKey,
  71         deRefStablePtrIdKey, doubleDataConKey, doublePrimTyConKey,
  72         doubleTyConKey, enumClassKey, enumFromClassOpKey,
  73         enumFromThenClassOpKey, enumFromThenToClassOpKey,
  74         enumFromToClassOpKey, eqClassKey, eqClassOpKey, eqStringIdKey,
  75         errorIdKey, falseDataConKey, failMClassOpKey, filterIdKey,
  76         floatDataConKey, floatPrimTyConKey, floatTyConKey, floatingClassKey,
  77         foldlIdKey, foldrIdKey, foreignObjDataConKey, foreignObjPrimTyConKey,
  78         foreignObjTyConKey, fractionalClassKey, fromEnumClassOpKey,
  79         fromIntClassOpKey, fromIntegerClassOpKey, fromRationalClassOpKey,
  80         funTyConKey, functorClassKey, geClassOpKey, getTagIdKey,
  81         intDataConKey, intPrimTyConKey, intTyConKey, int8TyConKey,
  82         int16TyConKey, int32TyConKey, int64PrimTyConKey, int64TyConKey,
  83         smallIntegerDataConKey, largeIntegerDataConKey, integerMinusOneIdKey,
  84         integerPlusOneIdKey, integerPlusTwoIdKey, int2IntegerIdKey,
  85         integerTyConKey, integerZeroIdKey, integralClassKey,
  86         irrefutPatErrorIdKey, ixClassKey, listTyConKey, mainKey,
  87         makeStablePtrIdKey, mapIdKey, minusClassOpKey, monadClassKey,
  88         monadPlusClassKey, mutableArrayPrimTyConKey,
  89         mutableByteArrayPrimTyConKey, mutableByteArrayTyConKey,
  90         mutVarPrimTyConKey, nilDataConKey, noMethodBindingErrorIdKey,
  91         nonExhaustiveGuardsErrorIdKey, numClassKey, anyBoxConKey, ordClassKey,
  92         orderingTyConKey, otherwiseIdKey, parErrorIdKey, parIdKey,
  93         patErrorIdKey, plusIntegerIdKey, ratioDataConKey, ratioTyConKey,
  94         rationalTyConKey, readClassKey, realClassKey, realFloatClassKey,
  95         realFracClassKey, realWorldPrimIdKey, realWorldTyConKey,
  96         recConErrorIdKey, recSelErrIdKey, recUpdErrorIdKey, returnIOIdKey,
  97         returnMClassOpKey, runSTRepIdKey, showClassKey, ioTyConKey,
  98         ioDataConKey, stablePtrDataConKey, stablePtrPrimTyConKey,
  99         stablePtrTyConKey, stableNameDataConKey, stableNamePrimTyConKey,
 100         stableNameTyConKey, statePrimTyConKey, timesIntegerIdKey, typeConKey,
 101         kindConKey, boxityConKey, mVarPrimTyConKey, thenMClassOpKey,
 102         threadIdPrimTyConKey, toEnumClassOpKey, traceIdKey, trueDataConKey,
 103         unboundKey, unboxedConKey, unpackCStringUtf8IdKey,
 104         unpackCStringAppendIdKey, unpackCStringFoldrIdKey, unpackCStringIdKey,
 105         unsafeCoerceIdKey, ushowListIdKey, weakPrimTyConKey, wordDataConKey,
 106         wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
 107         word32TyConKey, word64PrimTyConKey, word64TyConKey, zipIdKey
 108
 109     ) where
 110
 111 #include "HsVersions.h"
 112
 113 import Module     ( ModuleName, mkPrelModule, mkSrcModule )
 114 import OccName    ( NameSpace, varName, dataName, tcName, clsName )
 115 import RdrName    ( RdrName, mkPreludeQual )
 116 import UniqFM
 117 import Unique     ( Unique, Uniquable(..), hasKey,
 118                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
 119                     mkPreludeTyConUnique, mkPreludeClassUnique
 120                   )
 121 import BasicTypes ( Boxity(..), Arity )
 122 import UniqFM     ( UniqFM, listToUFM )
 123 import Util       ( nOfThem )
 124 import Panic      ( panic )
 125 \end{code}
 126
 127
 128 %************************************************************************
 129 %*                                                                      *
 130 \subsection{Known key RdrNames}
 131 %*                                                                      *
 132 %************************************************************************
 133
 134 This section tells what the compiler knows about the
 135 assocation of names with uniques
 136
 137 \begin{code}
 138 knownKeyRdrNames :: [(RdrName, Unique)]
 139 knownKeyRdrNames
 140  =  [
 141         -- Type constructors (synonyms especially)
 142       (ioTyCon_RDR,             ioTyConKey)
 143     , (main_RDR,                mainKey)
 144     , (orderingTyCon_RDR,       orderingTyConKey)
 145     , (rationalTyCon_RDR,       rationalTyConKey)
 146     , (ratioDataCon_RDR,        ratioDataConKey)
 147     , (ratioTyCon_RDR,          ratioTyConKey)
 148     , (byteArrayTyCon_RDR,      byteArrayTyConKey)
 149     , (mutableByteArrayTyCon_RDR, mutableByteArrayTyConKey)
 150     , (foreignObjTyCon_RDR,     foreignObjTyConKey)
 151     , (bcoPrimTyCon_RDR,        bcoPrimTyConKey)
 152     , (stablePtrTyCon_RDR,      stablePtrTyConKey)
 153     , (stablePtrDataCon_RDR,    stablePtrDataConKey)
 154
 155         --  Classes.  *Must* include:
 156         --      classes that are grabbed by key (e.g., eqClassKey)
 157         --      classes in "Class.standardClassKeys" (quite a few)
 158     , (eqClass_RDR,             eqClassKey)             -- mentioned, derivable
 159     , (ordClass_RDR,            ordClassKey)            -- derivable
 160     , (boundedClass_RDR,        boundedClassKey)        -- derivable
 161     , (numClass_RDR,            numClassKey)            -- mentioned, numeric
 162     , (enumClass_RDR,           enumClassKey)           -- derivable
 163     , (monadClass_RDR,          monadClassKey)
 164     , (monadPlusClass_RDR,      monadPlusClassKey)
 165     , (functorClass_RDR,        functorClassKey)
 166     , (showClass_RDR,           showClassKey)           -- derivable
 167     , (realClass_RDR,           realClassKey)           -- numeric
 168     , (integralClass_RDR,       integralClassKey)       -- numeric
 169     , (fractionalClass_RDR,     fractionalClassKey)     -- numeric
 170     , (floatingClass_RDR,       floatingClassKey)       -- numeric
 171     , (realFracClass_RDR,       realFracClassKey)       -- numeric
 172     , (realFloatClass_RDR,      realFloatClassKey)      -- numeric
 173     , (readClass_RDR,           readClassKey)           -- derivable
 174     , (ixClass_RDR,             ixClassKey)             -- derivable (but it isn't Prelude.Ix; hmmm)
 175     , (ccallableClass_RDR,      cCallableClassKey)      -- mentioned, ccallish
 176     , (creturnableClass_RDR,    cReturnableClassKey)    -- mentioned, ccallish
 177
 178         -- ClassOps
 179     , (fromInt_RDR,             fromIntClassOpKey)
 180     , (fromInteger_RDR,         fromIntegerClassOpKey)
 181     , (ge_RDR,                  geClassOpKey)
 182     , (minus_RDR,               minusClassOpKey)
 183     , (enumFrom_RDR,            enumFromClassOpKey)
 184     , (enumFromThen_RDR,        enumFromThenClassOpKey)
 185     , (enumFromTo_RDR,          enumFromToClassOpKey)
 186     , (enumFromThenTo_RDR,      enumFromThenToClassOpKey)
 187     , (fromEnum_RDR,            fromEnumClassOpKey)
 188     , (toEnum_RDR,              toEnumClassOpKey)
 189     , (eq_RDR,                  eqClassOpKey)
 190     , (thenM_RDR,               thenMClassOpKey)
 191     , (returnM_RDR,             returnMClassOpKey)
 192     , (failM_RDR,               failMClassOpKey)
 193     , (fromRational_RDR,        fromRationalClassOpKey)
 194
 195     , (deRefStablePtr_RDR,      deRefStablePtrIdKey)
 196     , (makeStablePtr_RDR,       makeStablePtrIdKey)
 197     , (bindIO_RDR,              bindIOIdKey)
 198     , (returnIO_RDR,            returnIOIdKey)
 199
 200         -- Strings and lists
 201     , (map_RDR,                 mapIdKey)
 202     , (append_RDR,              appendIdKey)
 203     , (unpackCString_RDR,       unpackCStringIdKey)
 204     , (unpackCStringAppend_RDR, unpackCStringAppendIdKey)
 205     , (unpackCStringFoldr_RDR,  unpackCStringFoldrIdKey)
 206     , (unpackCStringUtf8_RDR,   unpackCStringUtf8IdKey)
 207
 208         -- List operations
 209     , (concat_RDR,              concatIdKey)
 210     , (filter_RDR,              filterIdKey)
 211     , (zip_RDR,                 zipIdKey)
 212     , (foldr_RDR,               foldrIdKey)
 213     , (build_RDR,               buildIdKey)
 214     , (augment_RDR,             augmentIdKey)
 215
 216         -- FFI primitive types that are not wired-in.
 217     , (int8TyCon_RDR,           int8TyConKey)
 218     , (int16TyCon_RDR,          int16TyConKey)
 219     , (int32TyCon_RDR,          int32TyConKey)
 220     , (int64TyCon_RDR,          int64TyConKey)
 221     , (word8TyCon_RDR,          word8TyConKey)
 222     , (word16TyCon_RDR,         word16TyConKey)
 223     , (word32TyCon_RDR,         word32TyConKey)
 224     , (word64TyCon_RDR,         word64TyConKey)
 225
 226         -- Others
 227     , (otherwiseId_RDR,         otherwiseIdKey)
 228     , (plusInteger_RDR,         plusIntegerIdKey)
 229     , (timesInteger_RDR,        timesIntegerIdKey)
 230     , (eqString_RDR,            eqStringIdKey)
 231     , (assert_RDR,              assertIdKey)
 232     , (runSTRep_RDR,            runSTRepIdKey)
 233     ]
 234 \end{code}
 235
 236
 237 %************************************************************************
 238 %*                                                                      *
 239 \subsection{Module names}
 240 %*                                                                      *
 241 %************************************************************************
 242
 243 \begin{code}
 244 pRELUDE_Name      = mkSrcModule "Prelude"
 245 pREL_GHC_Name     = mkSrcModule "PrelGHC"          -- Primitive types and values
 246 pREL_BASE_Name    = mkSrcModule "PrelBase"
 247 pREL_ENUM_Name    = mkSrcModule "PrelEnum"
 248 pREL_SHOW_Name    = mkSrcModule "PrelShow"
 249 pREL_READ_Name    = mkSrcModule "PrelRead"
 250 pREL_NUM_Name     = mkSrcModule "PrelNum"
 251 pREL_LIST_Name    = mkSrcModule "PrelList"
 252 pREL_TUP_Name     = mkSrcModule "PrelTup"
 253 pREL_PACK_Name    = mkSrcModule "PrelPack"
 254 pREL_CONC_Name    = mkSrcModule "PrelConc"
 255 pREL_IO_BASE_Name = mkSrcModule "PrelIOBase"
 256 pREL_ST_Name      = mkSrcModule "PrelST"
 257 pREL_ARR_Name     = mkSrcModule "PrelArr"
 258 pREL_BYTEARR_Name = mkSrcModule "PrelByteArr"
 259 pREL_FOREIGN_Name = mkSrcModule "PrelForeign"
 260 pREL_STABLE_Name  = mkSrcModule "PrelStable"
 261 pREL_ADDR_Name    = mkSrcModule "PrelAddr"
 262 pREL_ERR_Name     = mkSrcModule "PrelErr"
 263 pREL_REAL_Name    = mkSrcModule "PrelReal"
 264 pREL_FLOAT_Name   = mkSrcModule "PrelFloat"
 265
 266 pREL_MAIN_Name   = mkSrcModule "PrelMain"
 267 mAIN_Name        = mkSrcModule "Main"
 268 iNT_Name         = mkSrcModule "Int"
 269 wORD_Name        = mkSrcModule "Word"
 270
 271 pREL_GHC     = mkPrelModule pREL_GHC_Name
 272 pREL_BASE    = mkPrelModule pREL_BASE_Name
 273 pREL_ADDR    = mkPrelModule pREL_ADDR_Name
 274 pREL_STABLE  = mkPrelModule pREL_STABLE_Name
 275 pREL_IO_BASE = mkPrelModule pREL_IO_BASE_Name
 276 pREL_PACK    = mkPrelModule pREL_PACK_Name
 277 pREL_ERR     = mkPrelModule pREL_ERR_Name
 278 pREL_NUM     = mkPrelModule pREL_NUM_Name
 279 pREL_REAL    = mkPrelModule pREL_REAL_Name
 280 pREL_FLOAT   = mkPrelModule pREL_FLOAT_Name
 281 \end{code}
 282
 283 %************************************************************************
 284 %*                                                                      *
 285 \subsection{Constructing the names of tuples
 286 %*                                                                      *
 287 %************************************************************************
 288
 289 \begin{code}
 290 mkTupNameStr :: Boxity -> Int -> (ModuleName, FAST_STRING)
 291
 292 mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()"))
 293 mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???"
 294 mkTupNameStr Boxed 2 = (pREL_TUP_Name, _PK_ "(,)")   -- not strictly necessary
 295 mkTupNameStr Boxed 3 = (pREL_TUP_Name, _PK_ "(,,)")  -- ditto
 296 mkTupNameStr Boxed 4 = (pREL_TUP_Name, _PK_ "(,,,)") -- ditto
 297 mkTupNameStr Boxed n = (pREL_TUP_Name, _PK_ ("(" ++ nOfThem (n-1) ',' ++ ")"))
 298
 299 mkTupNameStr Unboxed 0 = panic "Name.mkUbxTupNameStr: 0 ???"
 300 mkTupNameStr Unboxed 1 = (pREL_GHC_Name, _PK_ "(# #)") -- 1 and 0 both make sense!!!
 301 mkTupNameStr Unboxed 2 = (pREL_GHC_Name, _PK_ "(#,#)")
 302 mkTupNameStr Unboxed 3 = (pREL_GHC_Name, _PK_ "(#,,#)")
 303 mkTupNameStr Unboxed 4 = (pREL_GHC_Name, _PK_ "(#,,,#)")
 304 mkTupNameStr Unboxed n = (pREL_GHC_Name, _PK_ ("(#" ++ nOfThem (n-1) ',' ++ "#)"))
 305
 306 mkTupConRdrName :: NameSpace -> Boxity -> Arity -> RdrName
 307 mkTupConRdrName space boxity arity   = case mkTupNameStr boxity arity of
 308                                           (mod, occ) -> mkPreludeQual space mod occ
 309 \end{code}
 310
 311
 312
 313 %************************************************************************
 314 %*                                                                      *
 315 \subsection{Commonly-used RdrNames}
 316 %*                                                                      *
 317 %************************************************************************
 318
 319 These RdrNames are not really "built in", but some parts of the compiler
 320 (notably the deriving mechanism) need to mention their names, and it's convenient
 321 to write them all down in one place.
 322
 323 \begin{code}
 324 main_RDR                = varQual mAIN_Name      SLIT("main")
 325
 326 ioTyCon_RDR             = tcQual   pREL_IO_BASE_Name SLIT("IO")
 327 ioDataCon_RDR           = dataQual pREL_IO_BASE_Name SLIT("IO")
 328 bindIO_RDR              = varQual  pREL_IO_BASE_Name SLIT("bindIO")
 329 returnIO_RDR            = varQual  pREL_IO_BASE_Name SLIT("returnIO")
 330
 331
 332 rationalTyCon_RDR       = tcQual   pREL_REAL_Name  SLIT("Rational")
 333 ratioTyCon_RDR          = tcQual   pREL_REAL_Name  SLIT("Ratio")
 334 ratioDataCon_RDR        = dataQual pREL_REAL_Name  SLIT(":%")
 335
 336 byteArrayTyCon_RDR              = tcQual pREL_BYTEARR_Name  SLIT("ByteArray")
 337 mutableByteArrayTyCon_RDR       = tcQual pREL_BYTEARR_Name  SLIT("MutableByteArray")
 338
 339 foreignObjTyCon_RDR     = tcQual   pREL_IO_BASE_Name SLIT("ForeignObj")
 340 bcoPrimTyCon_RDR        = tcQual   pREL_BASE_Name SLIT("BCO#")
 341 stablePtrTyCon_RDR      = tcQual   pREL_STABLE_Name SLIT("StablePtr")
 342 stablePtrDataCon_RDR    = dataQual pREL_STABLE_Name SLIT("StablePtr")
 343 deRefStablePtr_RDR      = varQual  pREL_STABLE_Name SLIT("deRefStablePtr")
 344 makeStablePtr_RDR       = varQual  pREL_STABLE_Name SLIT("makeStablePtr")
 345
 346 -- Random PrelBase data types and constructors
 347 intTyCon_RDR       = tcQual   pREL_BASE_Name SLIT("Int")
 348 orderingTyCon_RDR  = tcQual   pREL_BASE_Name SLIT("Ordering")
 349 mkInt_RDR          = dataQual pREL_BASE_Name SLIT("I#")
 350 false_RDR          = dataQual pREL_BASE_Name SLIT("False")
 351 true_RDR           = dataQual pREL_BASE_Name SLIT("True")
 352
 353 -- Random PrelBase functions
 354 otherwiseId_RDR    = varQual pREL_BASE_Name SLIT("otherwise")
 355 and_RDR            = varQual pREL_BASE_Name SLIT("&&")
 356 not_RDR            = varQual pREL_BASE_Name SLIT("not")
 357 compose_RDR        = varQual pREL_BASE_Name SLIT(".")
 358 append_RDR         = varQual pREL_BASE_Name SLIT("++")
 359 foldr_RDR          = varQual pREL_BASE_Name SLIT("foldr")
 360 map_RDR            = varQual pREL_BASE_Name SLIT("map")
 361 build_RDR          = varQual pREL_BASE_Name SLIT("build")
 362 augment_RDR        = varQual pREL_BASE_Name SLIT("augment")
 363 eqString_RDR       = varQual pREL_BASE_Name SLIT("eqString")
 364
 365 -- Strings
 366 unpackCString_RDR       = varQual pREL_BASE_Name SLIT("unpackCString#")
 367 unpackCStringAppend_RDR = varQual pREL_BASE_Name SLIT("unpackAppendCString#")
 368 unpackCStringFoldr_RDR  = varQual pREL_BASE_Name SLIT("unpackFoldrCString#")
 369 unpackCStringUtf8_RDR   = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#")
 370
 371 -- Classes Eq and Ord
 372 eqClass_RDR             = clsQual pREL_BASE_Name SLIT("Eq")
 373 ordClass_RDR            = clsQual pREL_BASE_Name SLIT("Ord")
 374 eq_RDR             = varQual pREL_BASE_Name SLIT("==")
 375 ne_RDR             = varQual pREL_BASE_Name SLIT("/=")
 376 le_RDR             = varQual pREL_BASE_Name SLIT("<=")
 377 lt_RDR             = varQual pREL_BASE_Name SLIT("<")
 378 ge_RDR             = varQual pREL_BASE_Name SLIT(">=")
 379 gt_RDR             = varQual pREL_BASE_Name SLIT(">")
 380 ltTag_RDR          = dataQual pREL_BASE_Name SLIT("LT")
 381 eqTag_RDR          = dataQual pREL_BASE_Name SLIT("EQ")
 382 gtTag_RDR          = dataQual pREL_BASE_Name SLIT("GT")
 383 max_RDR            = varQual pREL_BASE_Name SLIT("max")
 384 min_RDR            = varQual pREL_BASE_Name SLIT("min")
 385 compare_RDR        = varQual pREL_BASE_Name SLIT("compare")
 386
 387 -- Class Monad
 388 monadClass_RDR     = clsQual pREL_BASE_Name SLIT("Monad")
 389 monadPlusClass_RDR = clsQual pREL_BASE_Name SLIT("MonadPlus")
 390 thenM_RDR          = varQual pREL_BASE_Name SLIT(">>=")
 391 returnM_RDR        = varQual pREL_BASE_Name SLIT("return")
 392 failM_RDR          = varQual pREL_BASE_Name SLIT("fail")
 393
 394 -- Class Functor
 395 functorClass_RDR        = clsQual pREL_BASE_Name SLIT("Functor")
 396
 397 -- Class Show
 398 showClass_RDR      = clsQual pREL_SHOW_Name SLIT("Show")
 399 showList___RDR     = varQual pREL_SHOW_Name SLIT("showList__")
 400 showsPrec_RDR      = varQual pREL_SHOW_Name SLIT("showsPrec")
 401 showList_RDR       = varQual pREL_SHOW_Name SLIT("showList")
 402 showSpace_RDR      = varQual pREL_SHOW_Name SLIT("showSpace")
 403 showString_RDR     = varQual pREL_SHOW_Name SLIT("showString")
 404 showParen_RDR      = varQual pREL_SHOW_Name SLIT("showParen")
 405
 406
 407 -- Class Read
 408 readClass_RDR      = clsQual pREL_READ_Name SLIT("Read")
 409 readsPrec_RDR      = varQual pREL_READ_Name SLIT("readsPrec")
 410 readList_RDR       = varQual pREL_READ_Name SLIT("readList")
 411 readParen_RDR      = varQual pREL_READ_Name SLIT("readParen")
 412 lex_RDR            = varQual pREL_READ_Name SLIT("lex")
 413 readList___RDR     = varQual pREL_READ_Name SLIT("readList__")
 414
 415
 416 -- Class Num
 417 numClass_RDR       = clsQual pREL_NUM_Name SLIT("Num")
 418 fromInt_RDR        = varQual pREL_NUM_Name SLIT("fromInt")
 419 fromInteger_RDR    = varQual pREL_NUM_Name SLIT("fromInteger")
 420 minus_RDR          = varQual pREL_NUM_Name SLIT("-")
 421 negate_RDR         = varQual pREL_NUM_Name SLIT("negate")
 422 plus_RDR           = varQual pREL_NUM_Name SLIT("+")
 423 times_RDR          = varQual pREL_NUM_Name SLIT("*")
 424 plusInteger_RDR    = varQual pREL_NUM_Name SLIT("plusInteger")
 425 timesInteger_RDR   = varQual pREL_NUM_Name SLIT("timesInteger")
 426
 427 -- Other numberic classes
 428 realClass_RDR           = clsQual pREL_REAL_Name  SLIT("Real")
 429 integralClass_RDR       = clsQual pREL_REAL_Name  SLIT("Integral")
 430 realFracClass_RDR       = clsQual pREL_REAL_Name  SLIT("RealFrac")
 431 fractionalClass_RDR     = clsQual pREL_REAL_Name  SLIT("Fractional")
 432 fromRational_RDR        = varQual pREL_REAL_Name  SLIT("fromRational")
 433
 434 floatingClass_RDR       = clsQual pREL_FLOAT_Name  SLIT("Floating")
 435 realFloatClass_RDR      = clsQual pREL_FLOAT_Name  SLIT("RealFloat")
 436
 437 -- Class Ix
 438 ixClass_RDR        = clsQual pREL_ARR_Name SLIT("Ix")
 439 range_RDR          = varQual pREL_ARR_Name SLIT("range")
 440 index_RDR          = varQual pREL_ARR_Name SLIT("index")
 441 inRange_RDR        = varQual pREL_ARR_Name SLIT("inRange")
 442
 443 -- Class CCallable and CReturnable
 444 ccallableClass_RDR      = clsQual pREL_GHC_Name  SLIT("CCallable")
 445 creturnableClass_RDR    = clsQual pREL_GHC_Name  SLIT("CReturnable")
 446
 447 -- Class Enum
 448 enumClass_RDR      = clsQual pREL_ENUM_Name SLIT("Enum")
 449 succ_RDR           = varQual pREL_ENUM_Name SLIT("succ")
 450 pred_RDR           = varQual pREL_ENUM_Name SLIT("pred")
 451 toEnum_RDR         = varQual pREL_ENUM_Name SLIT("toEnum")
 452 fromEnum_RDR       = varQual pREL_ENUM_Name SLIT("fromEnum")
 453 enumFrom_RDR       = varQual pREL_ENUM_Name SLIT("enumFrom")
 454 enumFromTo_RDR     = varQual pREL_ENUM_Name SLIT("enumFromTo")
 455 enumFromThen_RDR   = varQual pREL_ENUM_Name SLIT("enumFromThen")
 456 enumFromThenTo_RDR = varQual pREL_ENUM_Name SLIT("enumFromThenTo")
 457
 458 -- Class Bounded
 459 boundedClass_RDR   = clsQual pREL_ENUM_Name SLIT("Bounded")
 460 minBound_RDR       = varQual pREL_ENUM_Name SLIT("minBound")
 461 maxBound_RDR       = varQual pREL_ENUM_Name SLIT("maxBound")
 462
 463
 464 -- List functions
 465 concat_RDR         = varQual pREL_LIST_Name SLIT("concat")
 466 filter_RDR         = varQual pREL_LIST_Name SLIT("filter")
 467 zip_RDR            = varQual pREL_LIST_Name SLIT("zip")
 468
 469 int8TyCon_RDR    = tcQual iNT_Name       SLIT("Int8")
 470 int16TyCon_RDR   = tcQual iNT_Name       SLIT("Int16")
 471 int32TyCon_RDR   = tcQual iNT_Name       SLIT("Int32")
 472 int64TyCon_RDR   = tcQual pREL_ADDR_Name SLIT("Int64")
 473
 474 word8TyCon_RDR    = tcQual wORD_Name      SLIT("Word8")
 475 word16TyCon_RDR   = tcQual wORD_Name      SLIT("Word16")
 476 word32TyCon_RDR   = tcQual wORD_Name      SLIT("Word32")
 477 word64TyCon_RDR   = tcQual pREL_ADDR_Name SLIT("Word64")
 478
 479 error_RDR          = varQual pREL_ERR_Name SLIT("error")
 480 assert_RDR         = varQual pREL_GHC_Name SLIT("assert")
 481 getTag_RDR         = varQual pREL_GHC_Name SLIT("getTag#")
 482 assertErr_RDR      = varQual pREL_ERR_Name SLIT("assertError")
 483 runSTRep_RDR       = varQual pREL_ST_Name  SLIT("runSTRep")
 484 \end{code}
 485
 486
 487 %************************************************************************
 488 %*                                                                      *
 489 \subsection{Local helpers}
 490 %*                                                                      *
 491 %************************************************************************
 492
 493 \begin{code}
 494 varQual  = mkPreludeQual varName
 495 dataQual = mkPreludeQual dataName
 496 tcQual   = mkPreludeQual tcName
 497 clsQual  = mkPreludeQual clsName
 498 \end{code}
 499
 500
 501 %************************************************************************
 502 %*                                                                      *
 503 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 504 %*                                                                      *
 505 %************************************************************************
 506
 507 \begin{code}
 508 boundedClassKey         = mkPreludeClassUnique 1
 509 enumClassKey            = mkPreludeClassUnique 2
 510 eqClassKey              = mkPreludeClassUnique 3
 511 floatingClassKey        = mkPreludeClassUnique 5
 512 fractionalClassKey      = mkPreludeClassUnique 6
 513 integralClassKey        = mkPreludeClassUnique 7
 514 monadClassKey           = mkPreludeClassUnique 8
 515 monadPlusClassKey       = mkPreludeClassUnique 9
 516 functorClassKey         = mkPreludeClassUnique 10
 517 numClassKey             = mkPreludeClassUnique 11
 518 ordClassKey             = mkPreludeClassUnique 12
 519 readClassKey            = mkPreludeClassUnique 13
 520 realClassKey            = mkPreludeClassUnique 14
 521 realFloatClassKey       = mkPreludeClassUnique 15
 522 realFracClassKey        = mkPreludeClassUnique 16
 523 showClassKey            = mkPreludeClassUnique 17
 524
 525 cCallableClassKey       = mkPreludeClassUnique 18
 526 cReturnableClassKey     = mkPreludeClassUnique 19
 527
 528 ixClassKey              = mkPreludeClassUnique 20
 529 \end{code}
 530
 531 %************************************************************************
 532 %*                                                                      *
 533 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 534 %*                                                                      *
 535 %************************************************************************
 536
 537 \begin{code}
 538 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 539 addrTyConKey                            = mkPreludeTyConUnique  2
 540 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 541 boolTyConKey                            = mkPreludeTyConUnique  4
 542 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 543 charPrimTyConKey                        = mkPreludeTyConUnique  7
 544 charTyConKey                            = mkPreludeTyConUnique  8
 545 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 546 doubleTyConKey                          = mkPreludeTyConUnique 10
 547 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 548 floatTyConKey                           = mkPreludeTyConUnique 12
 549 funTyConKey                             = mkPreludeTyConUnique 13
 550 intPrimTyConKey                         = mkPreludeTyConUnique 14
 551 intTyConKey                             = mkPreludeTyConUnique 15
 552 int8TyConKey                            = mkPreludeTyConUnique 16
 553 int16TyConKey                           = mkPreludeTyConUnique 17
 554 int32TyConKey                           = mkPreludeTyConUnique 18
 555 int64PrimTyConKey                       = mkPreludeTyConUnique 19
 556 int64TyConKey                           = mkPreludeTyConUnique 20
 557 integerTyConKey                         = mkPreludeTyConUnique 21
 558 listTyConKey                            = mkPreludeTyConUnique 22
 559 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 23
 560 foreignObjTyConKey                      = mkPreludeTyConUnique 24
 561 weakPrimTyConKey                        = mkPreludeTyConUnique 25
 562 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 26
 563 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 27
 564 orderingTyConKey                        = mkPreludeTyConUnique 28
 565 mVarPrimTyConKey                        = mkPreludeTyConUnique 29
 566 ratioTyConKey                           = mkPreludeTyConUnique 30
 567 rationalTyConKey                        = mkPreludeTyConUnique 31
 568 realWorldTyConKey                       = mkPreludeTyConUnique 32
 569 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 33
 570 stablePtrTyConKey                       = mkPreludeTyConUnique 34
 571 statePrimTyConKey                       = mkPreludeTyConUnique 35
 572 stableNamePrimTyConKey                  = mkPreludeTyConUnique 50
 573 stableNameTyConKey                      = mkPreludeTyConUnique 51
 574 mutableByteArrayTyConKey                = mkPreludeTyConUnique 52
 575 mutVarPrimTyConKey                      = mkPreludeTyConUnique 53
 576 ioTyConKey                              = mkPreludeTyConUnique 55
 577 byteArrayTyConKey                       = mkPreludeTyConUnique 56
 578 wordPrimTyConKey                        = mkPreludeTyConUnique 57
 579 wordTyConKey                            = mkPreludeTyConUnique 58
 580 word8TyConKey                           = mkPreludeTyConUnique 59
 581 word16TyConKey                          = mkPreludeTyConUnique 60
 582 word32TyConKey                          = mkPreludeTyConUnique 61
 583 word64PrimTyConKey                      = mkPreludeTyConUnique 62
 584 word64TyConKey                          = mkPreludeTyConUnique 63
 585 boxedConKey                             = mkPreludeTyConUnique 64
 586 unboxedConKey                           = mkPreludeTyConUnique 65
 587 anyBoxConKey                            = mkPreludeTyConUnique 66
 588 kindConKey                              = mkPreludeTyConUnique 67
 589 boxityConKey                            = mkPreludeTyConUnique 68
 590 typeConKey                              = mkPreludeTyConUnique 69
 591 threadIdPrimTyConKey                    = mkPreludeTyConUnique 70
 592 bcoPrimTyConKey                         = mkPreludeTyConUnique 71
 593 \end{code}
 594
 595 %************************************************************************
 596 %*                                                                      *
 597 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 598 %*                                                                      *
 599 %************************************************************************
 600
 601 \begin{code}
 602 addrDataConKey                          = mkPreludeDataConUnique  0
 603 charDataConKey                          = mkPreludeDataConUnique  1
 604 consDataConKey                          = mkPreludeDataConUnique  2
 605 doubleDataConKey                        = mkPreludeDataConUnique  3
 606 falseDataConKey                         = mkPreludeDataConUnique  4
 607 floatDataConKey                         = mkPreludeDataConUnique  5
 608 intDataConKey                           = mkPreludeDataConUnique  6
 609 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 610 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 611 foreignObjDataConKey                    = mkPreludeDataConUnique  9
 612 nilDataConKey                           = mkPreludeDataConUnique 10
 613 ratioDataConKey                         = mkPreludeDataConUnique 11
 614 stablePtrDataConKey                     = mkPreludeDataConUnique 12
 615 stableNameDataConKey                    = mkPreludeDataConUnique 13
 616 trueDataConKey                          = mkPreludeDataConUnique 14
 617 wordDataConKey                          = mkPreludeDataConUnique 15
 618 ioDataConKey                            = mkPreludeDataConUnique 16
 619 \end{code}
 620
 621 %************************************************************************
 622 %*                                                                      *
 623 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 624 %*                                                                      *
 625 %************************************************************************
 626
 627 \begin{code}
 628 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 629 appendIdKey                   = mkPreludeMiscIdUnique  2
 630 augmentIdKey                  = mkPreludeMiscIdUnique  3
 631 buildIdKey                    = mkPreludeMiscIdUnique  4
 632 errorIdKey                    = mkPreludeMiscIdUnique  5
 633 foldlIdKey                    = mkPreludeMiscIdUnique  6
 634 foldrIdKey                    = mkPreludeMiscIdUnique  7
 635 recSelErrIdKey                = mkPreludeMiscIdUnique  8
 636 integerMinusOneIdKey          = mkPreludeMiscIdUnique  9
 637 integerPlusOneIdKey           = mkPreludeMiscIdUnique 10
 638 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 11
 639 integerZeroIdKey              = mkPreludeMiscIdUnique 12
 640 int2IntegerIdKey              = mkPreludeMiscIdUnique 13
 641 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 15
 642 eqStringIdKey                 = mkPreludeMiscIdUnique 16
 643 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 17
 644 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
 645 parErrorIdKey                 = mkPreludeMiscIdUnique 20
 646 parIdKey                      = mkPreludeMiscIdUnique 21
 647 patErrorIdKey                 = mkPreludeMiscIdUnique 22
 648 realWorldPrimIdKey            = mkPreludeMiscIdUnique 23
 649 recConErrorIdKey              = mkPreludeMiscIdUnique 24
 650 recUpdErrorIdKey              = mkPreludeMiscIdUnique 25
 651 traceIdKey                    = mkPreludeMiscIdUnique 26
 652 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 27
 653 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 28
 654 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 29
 655 unpackCStringIdKey            = mkPreludeMiscIdUnique 30
 656 ushowListIdKey                = mkPreludeMiscIdUnique 31
 657 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 658 concatIdKey                   = mkPreludeMiscIdUnique 33
 659 filterIdKey                   = mkPreludeMiscIdUnique 34
 660 zipIdKey                      = mkPreludeMiscIdUnique 35
 661 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 662 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 663 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 664 makeStablePtrIdKey            = mkPreludeMiscIdUnique 39
 665 getTagIdKey                   = mkPreludeMiscIdUnique 40
 666 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 667 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 668 \end{code}
 669
 670 Certain class operations from Prelude classes.  They get their own
 671 uniques so we can look them up easily when we want to conjure them up
 672 during type checking.
 673
 674 \begin{code}
 675 fromIntClassOpKey             = mkPreludeMiscIdUnique 101
 676 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
 677 minusClassOpKey               = mkPreludeMiscIdUnique 103
 678 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
 679 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
 680 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
 681 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
 682 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
 683 eqClassOpKey                  = mkPreludeMiscIdUnique 109
 684 geClassOpKey                  = mkPreludeMiscIdUnique 110
 685 failMClassOpKey               = mkPreludeMiscIdUnique 112
 686 thenMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
 687         -- Just a place holder for  unbound variables  produced by the renamer:
 688 unboundKey                    = mkPreludeMiscIdUnique 114
 689 fromEnumClassOpKey            = mkPreludeMiscIdUnique 115
 690
 691 mainKey                       = mkPreludeMiscIdUnique 116
 692 returnMClassOpKey             = mkPreludeMiscIdUnique 117
 693 otherwiseIdKey                = mkPreludeMiscIdUnique 118
 694 toEnumClassOpKey              = mkPreludeMiscIdUnique 119
 695 mapIdKey                      = mkPreludeMiscIdUnique 120
 696 \end{code}
 697
 698 \begin{code}
 699 assertIdKey                   = mkPreludeMiscIdUnique 121
 700 runSTRepIdKey                 = mkPreludeMiscIdUnique 122
 701 \end{code}
 702
 703
 704 %************************************************************************
 705 %*                                                                      *
 706 \subsection[Class-std-groups]{Standard groups of Prelude classes}
 707 %*                                                                      *
 708 %************************************************************************
 709
 710 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
 711 (@TcDeriv@).
 712
 713 @derivingOccurrences@ maps a class name to a list of the (qualified) occurrences
 714 that will be mentioned by  the derived code for the class when it is later generated.
 715 We don't need to put in things that are WiredIn (because they are already mapped to their
 716 correct name by the @NameSupply@.  The class itself, and all its class ops, is
 717 already flagged as an occurrence so we don't need to mention that either.
 718
 719 @derivingOccurrences@ has an item for every derivable class, even if that item is empty,
 720 because we treat lookup failure as indicating that the class is illegal in a deriving clause.
 721
 722 \begin{code}
 723 derivingOccurrences :: UniqFM [RdrName]
 724 derivingOccurrences = listToUFM deriving_occ_info
 725
 726 derivableClassKeys  = map fst deriving_occ_info
 727
 728 deriving_occ_info
 729   = [ (eqClassKey,      [intTyCon_RDR, and_RDR, not_RDR])
 730     , (ordClassKey,     [intTyCon_RDR, compose_RDR, eqTag_RDR])
 731                                 -- EQ (from Ordering) is needed to force in the constructors
 732                                 -- as well as the type constructor.
 733     , (enumClassKey,    [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
 734                                 -- The last two Enum deps are only used to produce better
 735                                 -- error msgs for derived toEnum methods.
 736     , (boundedClassKey, [intTyCon_RDR])
 737     , (showClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
 738                          showParen_RDR, showSpace_RDR, showList___RDR])
 739     , (readClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
 740                          foldr_RDR, build_RDR,
 741                              -- foldr and build required for list comprehension
 742                              -- KSW 2000-06
 743                          lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
 744                              -- returnM (and the rest of the Monad class decl)
 745                              -- will be forced in as result of depending
 746                              -- on thenM.   -- SOF 1/99
 747     , (ixClassKey,      [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
 748                          foldr_RDR, build_RDR,
 749                              -- foldr and build required for list comprehension used
 750                              -- with single constructor types  -- KSW 2000-06
 751                          returnM_RDR, failM_RDR])
 752                              -- the last two are needed to force returnM, thenM and failM
 753                              -- in before typechecking the list(monad) comprehension
 754                              -- generated for derived Ix instances (range method)
 755                              -- of single constructor types.  -- SOF 8/97
 756     ]
 757         -- intTyCon: Practically any deriving needs Int, either for index calculations,
 758         --              or for taggery.
 759         -- ordClass: really it's the methods that are actually used.
 760         -- numClass: for Int literals
 761 \end{code}
 762
 763
 764 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
 765 even though every numeric class has these two as a superclass,
 766 because the list of ambiguous dictionaries hasn't been simplified.
 767
 768 \begin{code}
 769 numericClassKeys =
 770         [ numClassKey
 771         , realClassKey
 772         , integralClassKey
 773         ]
 774         ++ fractionalClassKeys
 775
 776 fractionalClassKeys =
 777         [ fractionalClassKey
 778         , floatingClassKey
 779         , realFracClassKey
 780         , realFloatClassKey
 781         ]
 782
 783         -- the strictness analyser needs to know about numeric types
 784         -- (see SaAbsInt.lhs)
 785 numericTyKeys =
 786         [ addrTyConKey
 787         , wordTyConKey
 788         , intTyConKey
 789         , integerTyConKey
 790         , doubleTyConKey
 791         , floatTyConKey
 792         ]
 793
 794 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
 795         [ readClassKey
 796         ]
 797
 798 cCallishClassKeys =
 799         [ cCallableClassKey
 800         , cReturnableClassKey
 801         ]
 802
 803         -- Renamer always imports these data decls replete with constructors
 804         -- so that desugarer can always see their constructors.  Ugh!
 805 cCallishTyKeys =
 806         [ addrTyConKey
 807         , wordTyConKey
 808         , byteArrayTyConKey
 809         , mutableByteArrayTyConKey
 810         , foreignObjTyConKey
 811         , stablePtrTyConKey
 812         , int8TyConKey
 813         , int16TyConKey
 814         , int32TyConKey
 815         , int64TyConKey
 816         , word8TyConKey
 817         , word16TyConKey
 818         , word32TyConKey
 819         , word64TyConKey
 820         ]
 821
 822 standardClassKeys
 823   = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys
 824     --
 825     -- We have to have "CCallable" and "CReturnable" in the standard
 826     -- classes, so that if you go...
 827     --
 828     --      _ccall_ foo ... 93{-numeric literal-} ...
 829     --
 830     -- ... it can do The Right Thing on the 93.
 831
 832 noDictClassKeys         -- These classes are used only for type annotations;
 833                         -- they are not implemented by dictionaries, ever.
 834   = cCallishClassKeys
 835 \end{code}
 836