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