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