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