ghc/compiler/prelude/PrelNames.lhs

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