ghc/compiler/prelude/PrelNames.lhs

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