ghc/compiler/prelude/PrelNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[PrelNames]{Definitions of prelude modules and names}
   5
   6
   7 Nota Bene: all Names defined in here should come from the base package
   8
   9 * ModuleNames for prelude modules,
  10         e.g.    pREL_BASE_Name :: ModuleName
  11
  12 * Modules for prelude modules
  13         e.g.    pREL_Base :: Module
  14
  15 * Uniques for Ids, DataCons, TyCons and Classes that the compiler
  16   "knows about" in some way
  17         e.g.    intTyConKey :: Unique
  18                 minusClassOpKey :: Unique
  19
  20 * Names for Ids, DataCons, TyCons and Classes that the compiler
  21   "knows about" in some way
  22         e.g.    intTyConName :: Name
  23                 minusName    :: Name
  24   One of these Names contains
  25         (a) the module and occurrence name of the thing
  26         (b) its Unique
  27   The may way the compiler "knows about" one of these things is
  28   where the type checker or desugarer needs to look it up. For
  29   example, when desugaring list comprehensions the desugarer
  30   needs to conjure up 'foldr'.  It does this by looking up
  31   foldrName in the environment.
  32
  33 * RdrNames for Ids, DataCons etc that the compiler may emit into
  34   generated code (e.g. for deriving).  It's not necessary to know
  35   the uniques for these guys, only their names
  36
  37
  38 \begin{code}
  39 module PrelNames (
  40         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
  41
  42         -----------------------------------------------------------
  43         module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName
  44                                 --                 (b) Uniques e.g. intTyConKey
  45                                 --                 (c) Groups of classes and types
  46                                 --                 (d) miscellaneous things
  47                                 -- So many that we export them all
  48     ) where
  49
  50 #include "HsVersions.h"
  51
  52 import Module     ( Module, mkModule )
  53 import OccName    ( dataName, tcName, clsName, varName, mkOccFS
  54                   )
  55
  56 import RdrName    ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
  57 import Unique     ( Unique, Uniquable(..), hasKey,
  58                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
  59                     mkPreludeTyConUnique, mkPreludeClassUnique,
  60                     mkTupleTyConUnique
  61                   )
  62 import BasicTypes ( Boxity(..), Arity )
  63 import Name       ( Name, mkInternalName, mkExternalName, nameModule )
  64 import SrcLoc     ( noSrcLoc )
  65 import FastString
  66 \end{code}
  67
  68
  69 %************************************************************************
  70 %*                                                                      *
  71 \subsection{Local Names}
  72 %*                                                                      *
  73 %************************************************************************
  74
  75 This *local* name is used by the interactive stuff
  76
  77 \begin{code}
  78 itName uniq = mkInternalName uniq (mkOccFS varName FSLIT("it")) noSrcLoc
  79 \end{code}
  80
  81 \begin{code}
  82 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
  83 -- during compiler debugging.
  84 mkUnboundName :: RdrName -> Name
  85 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcLoc
  86
  87 isUnboundName :: Name -> Bool
  88 isUnboundName name = name `hasKey` unboundKey
  89 \end{code}
  90
  91
  92 %************************************************************************
  93 %*                                                                      *
  94 \subsection{Known key Names}
  95 %*                                                                      *
  96 %************************************************************************
  97
  98 This section tells what the compiler knows about the assocation of
  99 names with uniques.  These ones are the *non* wired-in ones.  The
 100 wired in ones are defined in TysWiredIn etc.
 101
 102 \begin{code}
 103 basicKnownKeyNames :: [Name]
 104 basicKnownKeyNames
 105  = genericTyConNames
 106  ++ typeableClassNames
 107  ++ [   -- Type constructors (synonyms especially)
 108         ioTyConName, ioDataConName,
 109         runMainIOName,
 110         orderingTyConName,
 111         rationalTyConName,
 112         ratioDataConName,
 113         ratioTyConName,
 114         byteArrayTyConName,
 115         mutableByteArrayTyConName,
 116         integerTyConName, smallIntegerDataConName, largeIntegerDataConName,
 117
 118         --  Classes.  *Must* include:
 119         --      classes that are grabbed by key (e.g., eqClassKey)
 120         --      classes in "Class.standardClassKeys" (quite a few)
 121         eqClassName,                    -- mentioned, derivable
 122         ordClassName,                   -- derivable
 123         boundedClassName,               -- derivable
 124         numClassName,                   -- mentioned, numeric
 125         enumClassName,                  -- derivable
 126         monadClassName,
 127         functorClassName,
 128         realClassName,                  -- numeric
 129         integralClassName,              -- numeric
 130         fractionalClassName,            -- numeric
 131         floatingClassName,              -- numeric
 132         realFracClassName,              -- numeric
 133         realFloatClassName,             -- numeric
 134         dataClassName,
 135
 136         -- Numeric stuff
 137         negateName, minusName,
 138         fromRationalName, fromIntegerName,
 139         geName, eqName,
 140
 141         -- Enum stuff
 142         enumFromName, enumFromThenName,
 143         enumFromThenToName, enumFromToName,
 144         enumFromToPName, enumFromThenToPName,
 145
 146         -- Monad stuff
 147         thenIOName, bindIOName, returnIOName, failIOName,
 148         failMName, bindMName, thenMName, returnMName,
 149
 150         -- MonadRec stuff
 151         mfixName,
 152
 153         -- Arrow stuff
 154         arrAName, composeAName, firstAName,
 155         appAName, choiceAName, loopAName,
 156
 157         -- Ix stuff
 158         ixClassName,
 159
 160         -- Show stuff
 161         showClassName,
 162
 163         -- Read stuff
 164         readClassName,
 165
 166         -- Stable pointers
 167         newStablePtrName,
 168
 169         -- Strings and lists
 170         unpackCStringName, unpackCStringAppendName,
 171         unpackCStringFoldrName, unpackCStringUtf8Name,
 172
 173         -- List operations
 174         concatName, filterName,
 175         zipName, foldrName, buildName, augmentName, appendName,
 176
 177         -- Parallel array operations
 178         nullPName, lengthPName, replicatePName, mapPName,
 179         filterPName, zipPName, crossPName, indexPName,
 180         toPName, bpermutePName, bpermuteDftPName, indexOfPName,
 181
 182         -- FFI primitive types that are not wired-in.
 183         stablePtrTyConName, ptrTyConName, funPtrTyConName, addrTyConName,
 184         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
 185         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 186
 187         -- Others
 188         otherwiseIdName,
 189         plusIntegerName, timesIntegerName,
 190         eqStringName, assertName, assertErrorName, runSTRepName,
 191         printName, fstName, sndName,
 192
 193         -- MonadFix
 194         monadFixClassName, mfixName,
 195
 196         -- Splittable class
 197         splittableClassName, splitName,
 198
 199         -- Other classes
 200         randomClassName, randomGenClassName, monadPlusClassName,
 201
 202         -- Booleans
 203         andName, orName
 204
 205         -- The Either type
 206         , eitherTyConName, leftDataConName, rightDataConName
 207
 208         -- dotnet interop
 209         , objectTyConName, marshalObjectName, unmarshalObjectName
 210         , marshalStringName, unmarshalStringName, checkDotnetResName
 211     ]
 212
 213 genericTyConNames :: [Name]
 214 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
 215 \end{code}
 216
 217
 218 %************************************************************************
 219 %*                                                                      *
 220 \subsection{Module names}
 221 %*                                                                      *
 222 %************************************************************************
 223
 224
 225 --MetaHaskell Extension Add a new module here
 226 \begin{code}
 227 pRELUDE         = mkModule "Prelude"
 228 gHC_PRIM        = mkModule "GHC.Prim"      -- Primitive types and values
 229 pREL_BASE       = mkModule "GHC.Base"
 230 pREL_ENUM       = mkModule "GHC.Enum"
 231 pREL_SHOW       = mkModule "GHC.Show"
 232 pREL_READ       = mkModule "GHC.Read"
 233 pREL_NUM        = mkModule "GHC.Num"
 234 pREL_LIST       = mkModule "GHC.List"
 235 pREL_PARR       = mkModule "GHC.PArr"
 236 pREL_TUP        = mkModule "Data.Tuple"
 237 pREL_EITHER     = mkModule "Data.Either"
 238 pREL_PACK       = mkModule "GHC.Pack"
 239 pREL_CONC       = mkModule "GHC.Conc"
 240 pREL_IO_BASE    = mkModule "GHC.IOBase"
 241 pREL_ST         = mkModule "GHC.ST"
 242 pREL_ARR        = mkModule "GHC.Arr"
 243 pREL_BYTEARR    = mkModule "PrelByteArr"
 244 pREL_STABLE     = mkModule "GHC.Stable"
 245 pREL_ADDR       = mkModule "GHC.Addr"
 246 pREL_PTR        = mkModule "GHC.Ptr"
 247 pREL_ERR        = mkModule "GHC.Err"
 248 pREL_REAL       = mkModule "GHC.Real"
 249 pREL_FLOAT      = mkModule "GHC.Float"
 250 pREL_TOP_HANDLER= mkModule "GHC.TopHandler"
 251 sYSTEM_IO       = mkModule "System.IO"
 252 dYNAMIC         = mkModule "Data.Dynamic"
 253 tYPEABLE        = mkModule "Data.Typeable"
 254 gENERICS        = mkModule "Data.Generics.Basics"
 255 dOTNET          = mkModule "GHC.Dotnet"
 256
 257 rEAD_PREC       = mkModule "Text.ParserCombinators.ReadPrec"
 258 lEX             = mkModule "Text.Read.Lex"
 259
 260 mAIN            = mkModule "Main"
 261 pREL_INT        = mkModule "GHC.Int"
 262 pREL_WORD       = mkModule "GHC.Word"
 263 mONAD           = mkModule "Control.Monad"
 264 mONAD_FIX       = mkModule "Control.Monad.Fix"
 265 aRROW           = mkModule "Control.Arrow"
 266 aDDR            = mkModule "Addr"
 267 rANDOM          = mkModule "System.Random"
 268
 269 gLA_EXTS        = mkModule "GHC.Exts"
 270 rOOT_MAIN       = mkModule ":Main"              -- Root module for initialisation
 271         -- The ':xxx' makes a module name that the user can never
 272         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 273         -- module name still starts with a capital letter, which keeps
 274         -- the z-encoded version consistent.
 275
 276 iNTERACTIVE    = mkModule ":Interactive"
 277 thFAKE         = mkModule ":THFake"
 278 \end{code}
 279
 280 %************************************************************************
 281 %*                                                                      *
 282 \subsection{Constructing the names of tuples
 283 %*                                                                      *
 284 %************************************************************************
 285
 286 \begin{code}
 287 mkTupleModule :: Boxity -> Arity -> Module
 288 mkTupleModule Boxed   0 = pREL_BASE
 289 mkTupleModule Boxed   _ = pREL_TUP
 290 mkTupleModule Unboxed _ = gHC_PRIM
 291 \end{code}
 292
 293
 294 %************************************************************************
 295 %*                                                                      *
 296                         RdrNames
 297 %*                                                                      *
 298 %************************************************************************
 299
 300 \begin{code}
 301 main_RDR_Unqual         = mkUnqual varName FSLIT("main")
 302         -- We definitely don't want an Orig RdrName, because
 303         -- main might, in principle, be imported into module Main
 304
 305 eq_RDR                  = nameRdrName eqName
 306 ge_RDR                  = nameRdrName geName
 307 ne_RDR                  = varQual_RDR  pREL_BASE FSLIT("/=")
 308 le_RDR                  = varQual_RDR  pREL_BASE FSLIT("<=")
 309 gt_RDR                  = varQual_RDR  pREL_BASE FSLIT(">")
 310 compare_RDR             = varQual_RDR  pREL_BASE FSLIT("compare")
 311 ltTag_RDR               = dataQual_RDR pREL_BASE FSLIT("LT")
 312 eqTag_RDR               = dataQual_RDR pREL_BASE FSLIT("EQ")
 313 gtTag_RDR               = dataQual_RDR pREL_BASE FSLIT("GT")
 314
 315 eqClass_RDR             = nameRdrName eqClassName
 316 numClass_RDR            = nameRdrName numClassName
 317 ordClass_RDR            = nameRdrName ordClassName
 318 enumClass_RDR           = nameRdrName enumClassName
 319 monadClass_RDR          = nameRdrName monadClassName
 320
 321 map_RDR                 = varQual_RDR pREL_BASE FSLIT("map")
 322 append_RDR              = varQual_RDR pREL_BASE FSLIT("++")
 323
 324 foldr_RDR               = nameRdrName foldrName
 325 build_RDR               = nameRdrName buildName
 326 returnM_RDR             = nameRdrName returnMName
 327 bindM_RDR               = nameRdrName bindMName
 328 failM_RDR               = nameRdrName failMName
 329
 330 and_RDR                 = nameRdrName andName
 331
 332 left_RDR                = nameRdrName leftDataConName
 333 right_RDR               = nameRdrName rightDataConName
 334
 335 fromEnum_RDR            = varQual_RDR pREL_ENUM FSLIT("fromEnum")
 336 toEnum_RDR              = varQual_RDR pREL_ENUM FSLIT("toEnum")
 337
 338 enumFrom_RDR            = nameRdrName enumFromName
 339 enumFromTo_RDR          = nameRdrName enumFromToName
 340 enumFromThen_RDR        = nameRdrName enumFromThenName
 341 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 342
 343 ratioDataCon_RDR        = nameRdrName ratioDataConName
 344 plusInteger_RDR         = nameRdrName plusIntegerName
 345 timesInteger_RDR        = nameRdrName timesIntegerName
 346
 347 ioDataCon_RDR           = nameRdrName ioDataConName
 348
 349 eqString_RDR            = nameRdrName eqStringName
 350 unpackCString_RDR       = nameRdrName unpackCStringName
 351 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 352 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 353
 354 newStablePtr_RDR        = nameRdrName newStablePtrName
 355 addrDataCon_RDR         = dataQual_RDR aDDR FSLIT("A#")
 356 wordDataCon_RDR         = dataQual_RDR pREL_WORD FSLIT("W#")
 357
 358 bindIO_RDR              = nameRdrName bindIOName
 359 returnIO_RDR            = nameRdrName returnIOName
 360
 361 fromInteger_RDR         = nameRdrName fromIntegerName
 362 fromRational_RDR        = nameRdrName fromRationalName
 363 minus_RDR               = nameRdrName minusName
 364 times_RDR               = varQual_RDR  pREL_NUM FSLIT("*")
 365 plus_RDR                = varQual_RDR pREL_NUM FSLIT("+")
 366
 367 compose_RDR             = varQual_RDR pREL_BASE FSLIT(".")
 368
 369 not_RDR                 = varQual_RDR pREL_BASE FSLIT("not")
 370 getTag_RDR              = varQual_RDR pREL_BASE FSLIT("getTag")
 371 succ_RDR                = varQual_RDR pREL_ENUM FSLIT("succ")
 372 pred_RDR                = varQual_RDR pREL_ENUM FSLIT("pred")
 373 minBound_RDR            = varQual_RDR pREL_ENUM FSLIT("minBound")
 374 maxBound_RDR            = varQual_RDR pREL_ENUM FSLIT("maxBound")
 375 range_RDR               = varQual_RDR pREL_ARR FSLIT("range")
 376 inRange_RDR             = varQual_RDR pREL_ARR FSLIT("inRange")
 377 index_RDR               = varQual_RDR pREL_ARR FSLIT("index")
 378 unsafeIndex_RDR         = varQual_RDR pREL_ARR FSLIT("unsafeIndex")
 379 unsafeRangeSize_RDR     = varQual_RDR pREL_ARR FSLIT("unsafeRangeSize")
 380
 381 readList_RDR            = varQual_RDR pREL_READ FSLIT("readList")
 382 readListDefault_RDR     = varQual_RDR pREL_READ FSLIT("readListDefault")
 383 readListPrec_RDR        = varQual_RDR pREL_READ FSLIT("readListPrec")
 384 readListPrecDefault_RDR = varQual_RDR pREL_READ FSLIT("readListPrecDefault")
 385 readPrec_RDR            = varQual_RDR pREL_READ FSLIT("readPrec")
 386 parens_RDR              = varQual_RDR pREL_READ FSLIT("parens")
 387 choose_RDR              = varQual_RDR pREL_READ FSLIT("choose")
 388 lexP_RDR                = varQual_RDR pREL_READ FSLIT("lexP")
 389
 390 punc_RDR                = dataQual_RDR lEX FSLIT("Punc")
 391 ident_RDR               = dataQual_RDR lEX FSLIT("Ident")
 392 symbol_RDR              = dataQual_RDR lEX FSLIT("Symbol")
 393
 394 step_RDR                = varQual_RDR  rEAD_PREC FSLIT("step")
 395 alt_RDR                 = varQual_RDR  rEAD_PREC FSLIT("+++")
 396 reset_RDR               = varQual_RDR  rEAD_PREC FSLIT("reset")
 397 prec_RDR                = varQual_RDR  rEAD_PREC FSLIT("prec")
 398
 399 showList_RDR            = varQual_RDR pREL_SHOW FSLIT("showList")
 400 showList___RDR          = varQual_RDR pREL_SHOW FSLIT("showList__")
 401 showsPrec_RDR           = varQual_RDR pREL_SHOW FSLIT("showsPrec")
 402 showString_RDR          = varQual_RDR pREL_SHOW FSLIT("showString")
 403 showSpace_RDR           = varQual_RDR pREL_SHOW FSLIT("showSpace")
 404 showParen_RDR           = varQual_RDR pREL_SHOW FSLIT("showParen")
 405
 406 typeOf_RDR     = varQual_RDR tYPEABLE FSLIT("typeOf")
 407 mkTypeRep_RDR  = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
 408 mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
 409
 410 undefined_RDR = varQual_RDR pREL_ERR FSLIT("undefined")
 411
 412 crossDataCon_RDR   = dataQual_RDR pREL_BASE FSLIT(":*:")
 413 inlDataCon_RDR     = dataQual_RDR pREL_BASE FSLIT("Inl")
 414 inrDataCon_RDR     = dataQual_RDR pREL_BASE FSLIT("Inr")
 415 genUnitDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Unit")
 416
 417 ----------------------
 418 varQual_RDR  mod str = mkOrig mod (mkOccFS varName str)
 419 tcQual_RDR   mod str = mkOrig mod (mkOccFS tcName str)
 420 clsQual_RDR  mod str = mkOrig mod (mkOccFS clsName str)
 421 dataQual_RDR mod str = mkOrig mod (mkOccFS dataName str)
 422 \end{code}
 423
 424 %************************************************************************
 425 %*                                                                      *
 426 \subsection{Known-key names}
 427 %*                                                                      *
 428 %************************************************************************
 429
 430 Many of these Names are not really "built in", but some parts of the
 431 compiler (notably the deriving mechanism) need to mention their names,
 432 and it's convenient to write them all down in one place.
 433
 434 --MetaHaskell Extension  add the constrs and the lower case case
 435 -- guys as well (perhaps) e.g. see  trueDataConName     below
 436
 437
 438 \begin{code}
 439 runMainIOName = varQual pREL_TOP_HANDLER FSLIT("runMainIO") runMainKey
 440
 441 orderingTyConName = tcQual   pREL_BASE FSLIT("Ordering") orderingTyConKey
 442
 443 eitherTyConName   = tcQual  pREL_EITHER     FSLIT("Either") eitherTyConKey
 444 leftDataConName   = conName eitherTyConName FSLIT("Left")   leftDataConKey
 445 rightDataConName  = conName eitherTyConName FSLIT("Right")  rightDataConKey
 446
 447 -- Generics
 448 crossTyConName     = tcQual   pREL_BASE FSLIT(":*:") crossTyConKey
 449 plusTyConName      = tcQual   pREL_BASE FSLIT(":+:") plusTyConKey
 450 genUnitTyConName   = tcQual   pREL_BASE FSLIT("Unit") genUnitTyConKey
 451
 452 -- Base strings Strings
 453 unpackCStringName       = varQual pREL_BASE FSLIT("unpackCString#") unpackCStringIdKey
 454 unpackCStringAppendName = varQual pREL_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey
 455 unpackCStringFoldrName  = varQual pREL_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
 456 unpackCStringUtf8Name   = varQual pREL_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
 457 eqStringName            = varQual pREL_BASE FSLIT("eqString")  eqStringIdKey
 458
 459 -- Base classes (Eq, Ord, Functor)
 460 eqClassName       = clsQual pREL_BASE FSLIT("Eq")      eqClassKey
 461 eqName            = methName eqClassName FSLIT("==")   eqClassOpKey
 462 ordClassName      = clsQual pREL_BASE FSLIT("Ord")     ordClassKey
 463 geName            = methName ordClassName FSLIT(">=")  geClassOpKey
 464 functorClassName  = clsQual pREL_BASE FSLIT("Functor") functorClassKey
 465
 466 -- Class Monad
 467 monadClassName     = clsQual pREL_BASE FSLIT("Monad")        monadClassKey
 468 thenMName          = methName monadClassName FSLIT(">>")     thenMClassOpKey
 469 bindMName          = methName monadClassName FSLIT(">>=")    bindMClassOpKey
 470 returnMName        = methName monadClassName FSLIT("return") returnMClassOpKey
 471 failMName          = methName monadClassName FSLIT("fail")   failMClassOpKey
 472
 473 -- Random PrelBase functions
 474 otherwiseIdName   = varQual pREL_BASE FSLIT("otherwise") otherwiseIdKey
 475 foldrName         = varQual pREL_BASE FSLIT("foldr")     foldrIdKey
 476 buildName         = varQual pREL_BASE FSLIT("build")     buildIdKey
 477 augmentName       = varQual pREL_BASE FSLIT("augment")   augmentIdKey
 478 appendName        = varQual pREL_BASE FSLIT("++")        appendIdKey
 479 andName           = varQual pREL_BASE FSLIT("&&")        andIdKey
 480 orName            = varQual pREL_BASE FSLIT("||")        orIdKey
 481 assertName        = varQual pREL_BASE FSLIT("assert")    assertIdKey
 482
 483 -- PrelTup
 484 fstName           = varQual pREL_TUP FSLIT("fst") fstIdKey
 485 sndName           = varQual pREL_TUP FSLIT("snd") sndIdKey
 486
 487 -- Module PrelNum
 488 numClassName      = clsQual pREL_NUM FSLIT("Num") numClassKey
 489 fromIntegerName   = methName numClassName FSLIT("fromInteger") fromIntegerClassOpKey
 490 minusName         = methName numClassName FSLIT("-") minusClassOpKey
 491 negateName        = methName numClassName FSLIT("negate") negateClassOpKey
 492 plusIntegerName   = varQual pREL_NUM FSLIT("plusInteger") plusIntegerIdKey
 493 timesIntegerName  = varQual pREL_NUM FSLIT("timesInteger") timesIntegerIdKey
 494 integerTyConName  = tcQual  pREL_NUM FSLIT("Integer") integerTyConKey
 495 smallIntegerDataConName = conName integerTyConName FSLIT("S#") smallIntegerDataConKey
 496 largeIntegerDataConName = conName integerTyConName FSLIT("J#") largeIntegerDataConKey
 497
 498 -- PrelReal types and classes
 499 rationalTyConName   = tcQual  pREL_REAL  FSLIT("Rational") rationalTyConKey
 500 ratioTyConName      = tcQual  pREL_REAL  FSLIT("Ratio") ratioTyConKey
 501 ratioDataConName    = conName ratioTyConName FSLIT(":%") ratioDataConKey
 502 realClassName       = clsQual pREL_REAL  FSLIT("Real") realClassKey
 503 integralClassName   = clsQual pREL_REAL  FSLIT("Integral") integralClassKey
 504 realFracClassName   = clsQual pREL_REAL  FSLIT("RealFrac") realFracClassKey
 505 fractionalClassName = clsQual pREL_REAL  FSLIT("Fractional") fractionalClassKey
 506 fromRationalName    = methName fractionalClassName  FSLIT("fromRational") fromRationalClassOpKey
 507
 508 -- PrelFloat classes
 509 floatingClassName  = clsQual  pREL_FLOAT FSLIT("Floating") floatingClassKey
 510 realFloatClassName = clsQual  pREL_FLOAT FSLIT("RealFloat") realFloatClassKey
 511
 512 -- Class Ix
 513 ixClassName = clsQual pREL_ARR FSLIT("Ix") ixClassKey
 514
 515 -- Class Typeable
 516 typeableClassName  = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey
 517 typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey
 518 typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey
 519 typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey
 520 typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey
 521 typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey
 522 typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey
 523 typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey
 524
 525 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 526                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 527                         , typeable6ClassName, typeable7ClassName ]
 528
 529 -- Class Data
 530 dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
 531
 532 -- Error module
 533 assertErrorName   = varQual pREL_ERR FSLIT("assertError") assertErrorIdKey
 534
 535 -- Enum module (Enum, Bounded)
 536 enumClassName      = clsQual pREL_ENUM FSLIT("Enum") enumClassKey
 537 enumFromName       = methName enumClassName FSLIT("enumFrom") enumFromClassOpKey
 538 enumFromToName     = methName enumClassName FSLIT("enumFromTo") enumFromToClassOpKey
 539 enumFromThenName   = methName enumClassName FSLIT("enumFromThen") enumFromThenClassOpKey
 540 enumFromThenToName = methName enumClassName FSLIT("enumFromThenTo") enumFromThenToClassOpKey
 541 boundedClassName   = clsQual pREL_ENUM FSLIT("Bounded") boundedClassKey
 542
 543 -- List functions
 544 concatName        = varQual pREL_LIST FSLIT("concat") concatIdKey
 545 filterName        = varQual pREL_LIST FSLIT("filter") filterIdKey
 546 zipName           = varQual pREL_LIST FSLIT("zip") zipIdKey
 547
 548 -- Class Show
 549 showClassName     = clsQual pREL_SHOW FSLIT("Show")       showClassKey
 550
 551 -- Class Read
 552 readClassName      = clsQual pREL_READ FSLIT("Read") readClassKey
 553
 554 -- parallel array types and functions
 555 enumFromToPName    = varQual pREL_PARR FSLIT("enumFromToP") enumFromToPIdKey
 556 enumFromThenToPName= varQual pREL_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey
 557 nullPName         = varQual pREL_PARR FSLIT("nullP")             nullPIdKey
 558 lengthPName       = varQual pREL_PARR FSLIT("lengthP")           lengthPIdKey
 559 replicatePName    = varQual pREL_PARR FSLIT("replicateP")        replicatePIdKey
 560 mapPName          = varQual pREL_PARR FSLIT("mapP")              mapPIdKey
 561 filterPName       = varQual pREL_PARR FSLIT("filterP")           filterPIdKey
 562 zipPName          = varQual pREL_PARR FSLIT("zipP")              zipPIdKey
 563 crossPName        = varQual pREL_PARR FSLIT("crossP")            crossPIdKey
 564 indexPName        = varQual pREL_PARR FSLIT("!:")                indexPIdKey
 565 toPName           = varQual pREL_PARR FSLIT("toP")               toPIdKey
 566 bpermutePName     = varQual pREL_PARR FSLIT("bpermuteP")    bpermutePIdKey
 567 bpermuteDftPName  = varQual pREL_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey
 568 indexOfPName      = varQual pREL_PARR FSLIT("indexOfP")     indexOfPIdKey
 569
 570 -- IOBase things
 571 ioTyConName       = tcQual  pREL_IO_BASE FSLIT("IO") ioTyConKey
 572 ioDataConName     = conName ioTyConName  FSLIT("IO") ioDataConKey
 573 thenIOName        = varQual pREL_IO_BASE FSLIT("thenIO") thenIOIdKey
 574 bindIOName        = varQual pREL_IO_BASE FSLIT("bindIO") bindIOIdKey
 575 returnIOName      = varQual pREL_IO_BASE FSLIT("returnIO") returnIOIdKey
 576 failIOName        = varQual pREL_IO_BASE FSLIT("failIO") failIOIdKey
 577
 578 -- IO things
 579 printName         = varQual sYSTEM_IO FSLIT("print") printIdKey
 580
 581 -- Int, Word, and Addr things
 582 int8TyConName     = tcQual pREL_INT  FSLIT("Int8") int8TyConKey
 583 int16TyConName    = tcQual pREL_INT  FSLIT("Int16") int16TyConKey
 584 int32TyConName    = tcQual pREL_INT  FSLIT("Int32") int32TyConKey
 585 int64TyConName    = tcQual pREL_INT  FSLIT("Int64") int64TyConKey
 586
 587 -- Word module
 588 word8TyConName    = tcQual  pREL_WORD FSLIT("Word8")  word8TyConKey
 589 word16TyConName   = tcQual  pREL_WORD FSLIT("Word16") word16TyConKey
 590 word32TyConName   = tcQual  pREL_WORD FSLIT("Word32") word32TyConKey
 591 word64TyConName   = tcQual  pREL_WORD FSLIT("Word64") word64TyConKey
 592 wordTyConName     = tcQual  pREL_WORD FSLIT("Word")   wordTyConKey
 593 wordDataConName   = conName wordTyConName FSLIT("W#") wordDataConKey
 594
 595 -- Addr module
 596 addrTyConName     = tcQual   aDDR FSLIT("Addr") addrTyConKey
 597
 598 -- PrelPtr module
 599 ptrTyConName      = tcQual   pREL_PTR FSLIT("Ptr") ptrTyConKey
 600 funPtrTyConName   = tcQual   pREL_PTR FSLIT("FunPtr") funPtrTyConKey
 601
 602 -- Byte array types
 603 byteArrayTyConName        = tcQual pREL_BYTEARR  FSLIT("ByteArray") byteArrayTyConKey
 604 mutableByteArrayTyConName = tcQual pREL_BYTEARR  FSLIT("MutableByteArray") mutableByteArrayTyConKey
 605
 606 -- Foreign objects and weak pointers
 607 stablePtrTyConName    = tcQual   pREL_STABLE FSLIT("StablePtr") stablePtrTyConKey
 608 newStablePtrName      = varQual  pREL_STABLE FSLIT("newStablePtr") newStablePtrIdKey
 609
 610 -- PrelST module
 611 runSTRepName       = varQual pREL_ST  FSLIT("runSTRep") runSTRepIdKey
 612
 613 -- The "split" Id for splittable implicit parameters
 614 splittableClassName = clsQual gLA_EXTS FSLIT("Splittable") splittableClassKey
 615 splitName           = methName splittableClassName FSLIT("split") splitIdKey
 616
 617 -- Recursive-do notation
 618 monadFixClassName  = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
 619 mfixName           = methName monadFixClassName FSLIT("mfix") mfixIdKey
 620
 621 -- Arrow notation
 622 arrAName           = varQual aRROW FSLIT("arr")   arrAIdKey
 623 composeAName       = varQual aRROW FSLIT(">>>")   composeAIdKey
 624 firstAName         = varQual aRROW FSLIT("first") firstAIdKey
 625 appAName           = varQual aRROW FSLIT("app")   appAIdKey
 626 choiceAName        = varQual aRROW FSLIT("|||")   choiceAIdKey
 627 loopAName          = varQual aRROW FSLIT("loop")  loopAIdKey
 628
 629 -- Other classes, needed for type defaulting
 630 monadPlusClassName  = clsQual mONAD FSLIT("MonadPlus")  monadPlusClassKey
 631 randomClassName     = clsQual rANDOM FSLIT("Random")    randomClassKey
 632 randomGenClassName  = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey
 633
 634 -- dotnet interop
 635 objectTyConName     = tcQual   dOTNET FSLIT("Object") objectTyConKey
 636         -- objectTyConName was "wTcQual", but that's gone now, and
 637         -- I can't see why it was wired in anyway...
 638 unmarshalObjectName = varQual  dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey
 639 marshalObjectName   = varQual  dOTNET FSLIT("marshalObject") marshalObjectIdKey
 640 marshalStringName   = varQual  dOTNET FSLIT("marshalString") marshalStringIdKey
 641 unmarshalStringName = varQual  dOTNET FSLIT("unmarshalString") unmarshalStringIdKey
 642 checkDotnetResName  = varQual  dOTNET FSLIT("checkResult")     checkDotnetResNameIdKey
 643 \end{code}
 644
 645 %************************************************************************
 646 %*                                                                      *
 647 \subsection{Local helpers}
 648 %*                                                                      *
 649 %************************************************************************
 650
 651 All these are original names; hence mkOrig
 652
 653 \begin{code}
 654 varQual  = mk_known_key_name varName
 655 tcQual   = mk_known_key_name tcName
 656 clsQual  = mk_known_key_name clsName
 657
 658 mk_known_key_name space mod str uniq
 659   = mkExternalName uniq mod (mkOccFS space str)
 660                    Nothing noSrcLoc
 661
 662 conName :: Name -> FastString -> Unique -> Name
 663 conName tycon occ uniq
 664   = mkExternalName uniq (nameModule tycon) (mkOccFS dataName occ)
 665                    (Just tycon) noSrcLoc
 666
 667 methName :: Name -> FastString -> Unique -> Name
 668 methName cls occ uniq
 669   = mkExternalName uniq (nameModule cls) (mkOccFS varName occ)
 670                    (Just cls) noSrcLoc
 671 \end{code}
 672
 673 %************************************************************************
 674 %*                                                                      *
 675 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 676 %*                                                                      *
 677 %************************************************************************
 678 --MetaHaskell extension hand allocate keys here
 679
 680 \begin{code}
 681 boundedClassKey         = mkPreludeClassUnique 1
 682 enumClassKey            = mkPreludeClassUnique 2
 683 eqClassKey              = mkPreludeClassUnique 3
 684 floatingClassKey        = mkPreludeClassUnique 5
 685 fractionalClassKey      = mkPreludeClassUnique 6
 686 integralClassKey        = mkPreludeClassUnique 7
 687 monadClassKey           = mkPreludeClassUnique 8
 688 dataClassKey            = mkPreludeClassUnique 9
 689 functorClassKey         = mkPreludeClassUnique 10
 690 numClassKey             = mkPreludeClassUnique 11
 691 ordClassKey             = mkPreludeClassUnique 12
 692 readClassKey            = mkPreludeClassUnique 13
 693 realClassKey            = mkPreludeClassUnique 14
 694 realFloatClassKey       = mkPreludeClassUnique 15
 695 realFracClassKey        = mkPreludeClassUnique 16
 696 showClassKey            = mkPreludeClassUnique 17
 697 ixClassKey              = mkPreludeClassUnique 18
 698
 699 typeableClassKey        = mkPreludeClassUnique 20
 700 typeable1ClassKey       = mkPreludeClassUnique 21
 701 typeable2ClassKey       = mkPreludeClassUnique 22
 702 typeable3ClassKey       = mkPreludeClassUnique 23
 703 typeable4ClassKey       = mkPreludeClassUnique 24
 704 typeable5ClassKey       = mkPreludeClassUnique 25
 705 typeable6ClassKey       = mkPreludeClassUnique 26
 706 typeable7ClassKey       = mkPreludeClassUnique 27
 707
 708 monadFixClassKey        = mkPreludeClassUnique 28
 709 splittableClassKey      = mkPreludeClassUnique 29
 710
 711 monadPlusClassKey       = mkPreludeClassUnique 30
 712 randomClassKey          = mkPreludeClassUnique 31
 713 randomGenClassKey       = mkPreludeClassUnique 32
 714 \end{code}
 715
 716 %************************************************************************
 717 %*                                                                      *
 718 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 719 %*                                                                      *
 720 %************************************************************************
 721
 722 \begin{code}
 723 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 724 addrTyConKey                            = mkPreludeTyConUnique  2
 725 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 726 boolTyConKey                            = mkPreludeTyConUnique  4
 727 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 728 charPrimTyConKey                        = mkPreludeTyConUnique  7
 729 charTyConKey                            = mkPreludeTyConUnique  8
 730 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 731 doubleTyConKey                          = mkPreludeTyConUnique 10
 732 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 733 floatTyConKey                           = mkPreludeTyConUnique 12
 734 funTyConKey                             = mkPreludeTyConUnique 13
 735 intPrimTyConKey                         = mkPreludeTyConUnique 14
 736 intTyConKey                             = mkPreludeTyConUnique 15
 737 int8TyConKey                            = mkPreludeTyConUnique 16
 738 int16TyConKey                           = mkPreludeTyConUnique 17
 739 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 740 int32TyConKey                           = mkPreludeTyConUnique 19
 741 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 742 int64TyConKey                           = mkPreludeTyConUnique 21
 743 integerTyConKey                         = mkPreludeTyConUnique 22
 744 listTyConKey                            = mkPreludeTyConUnique 23
 745 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 746 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 747 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 748 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 749 orderingTyConKey                        = mkPreludeTyConUnique 30
 750 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 751 ratioTyConKey                           = mkPreludeTyConUnique 32
 752 rationalTyConKey                        = mkPreludeTyConUnique 33
 753 realWorldTyConKey                       = mkPreludeTyConUnique 34
 754 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 755 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 756 statePrimTyConKey                       = mkPreludeTyConUnique 50
 757 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
 758 stableNameTyConKey                      = mkPreludeTyConUnique 52
 759 mutableByteArrayTyConKey                = mkPreludeTyConUnique 53
 760 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
 761 ioTyConKey                              = mkPreludeTyConUnique 56
 762 byteArrayTyConKey                       = mkPreludeTyConUnique 57
 763 wordPrimTyConKey                        = mkPreludeTyConUnique 58
 764 wordTyConKey                            = mkPreludeTyConUnique 59
 765 word8TyConKey                           = mkPreludeTyConUnique 60
 766 word16TyConKey                          = mkPreludeTyConUnique 61
 767 word32PrimTyConKey                      = mkPreludeTyConUnique 62
 768 word32TyConKey                          = mkPreludeTyConUnique 63
 769 word64PrimTyConKey                      = mkPreludeTyConUnique 64
 770 word64TyConKey                          = mkPreludeTyConUnique 65
 771 liftedConKey                            = mkPreludeTyConUnique 66
 772 unliftedConKey                          = mkPreludeTyConUnique 67
 773 anyBoxConKey                            = mkPreludeTyConUnique 68
 774 kindConKey                              = mkPreludeTyConUnique 69
 775 boxityConKey                            = mkPreludeTyConUnique 70
 776 typeConKey                              = mkPreludeTyConUnique 71
 777 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
 778 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
 779 ptrTyConKey                             = mkPreludeTyConUnique 74
 780 funPtrTyConKey                          = mkPreludeTyConUnique 75
 781 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
 782
 783 -- Generic Type Constructors
 784 crossTyConKey                           = mkPreludeTyConUnique 79
 785 plusTyConKey                            = mkPreludeTyConUnique 80
 786 genUnitTyConKey                         = mkPreludeTyConUnique 81
 787
 788 -- Parallel array type constructor
 789 parrTyConKey                            = mkPreludeTyConUnique 82
 790
 791 -- dotnet interop
 792 objectTyConKey                          = mkPreludeTyConUnique 83
 793
 794 eitherTyConKey                          = mkPreludeTyConUnique 84
 795
 796 ---------------- Template Haskell -------------------
 797 --      USES TyConUniques 100-129
 798 -----------------------------------------------------
 799
 800 unitTyConKey = mkTupleTyConUnique Boxed 0
 801 \end{code}
 802
 803 %************************************************************************
 804 %*                                                                      *
 805 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 806 %*                                                                      *
 807 %************************************************************************
 808
 809 \begin{code}
 810 charDataConKey                          = mkPreludeDataConUnique  1
 811 consDataConKey                          = mkPreludeDataConUnique  2
 812 doubleDataConKey                        = mkPreludeDataConUnique  3
 813 falseDataConKey                         = mkPreludeDataConUnique  4
 814 floatDataConKey                         = mkPreludeDataConUnique  5
 815 intDataConKey                           = mkPreludeDataConUnique  6
 816 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 817 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 818 nilDataConKey                           = mkPreludeDataConUnique 11
 819 ratioDataConKey                         = mkPreludeDataConUnique 12
 820 stableNameDataConKey                    = mkPreludeDataConUnique 14
 821 trueDataConKey                          = mkPreludeDataConUnique 15
 822 wordDataConKey                          = mkPreludeDataConUnique 16
 823 ioDataConKey                            = mkPreludeDataConUnique 17
 824
 825 -- Generic data constructors
 826 crossDataConKey                         = mkPreludeDataConUnique 20
 827 inlDataConKey                           = mkPreludeDataConUnique 21
 828 inrDataConKey                           = mkPreludeDataConUnique 22
 829 genUnitDataConKey                       = mkPreludeDataConUnique 23
 830
 831 -- Data constructor for parallel arrays
 832 parrDataConKey                          = mkPreludeDataConUnique 24
 833
 834 leftDataConKey                          = mkPreludeDataConUnique 25
 835 rightDataConKey                         = mkPreludeDataConUnique 26
 836 \end{code}
 837
 838 %************************************************************************
 839 %*                                                                      *
 840 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 841 %*                                                                      *
 842 %************************************************************************
 843
 844 \begin{code}
 845 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 846 augmentIdKey                  = mkPreludeMiscIdUnique  3
 847 appendIdKey                   = mkPreludeMiscIdUnique  4
 848 buildIdKey                    = mkPreludeMiscIdUnique  5
 849 errorIdKey                    = mkPreludeMiscIdUnique  6
 850 foldlIdKey                    = mkPreludeMiscIdUnique  7
 851 foldrIdKey                    = mkPreludeMiscIdUnique  8
 852 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
 853 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
 854 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
 855 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
 856 integerZeroIdKey              = mkPreludeMiscIdUnique 13
 857 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
 858 seqIdKey                      = mkPreludeMiscIdUnique 15
 859 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 860 eqStringIdKey                 = mkPreludeMiscIdUnique 17
 861 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
 862 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
 863 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
 864 parErrorIdKey                 = mkPreludeMiscIdUnique 21
 865 parIdKey                      = mkPreludeMiscIdUnique 22
 866 patErrorIdKey                 = mkPreludeMiscIdUnique 23
 867 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
 868 recConErrorIdKey              = mkPreludeMiscIdUnique 25
 869 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
 870 traceIdKey                    = mkPreludeMiscIdUnique 27
 871 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
 872 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
 873 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
 874 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
 875
 876 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 877 concatIdKey                   = mkPreludeMiscIdUnique 33
 878 filterIdKey                   = mkPreludeMiscIdUnique 34
 879 zipIdKey                      = mkPreludeMiscIdUnique 35
 880 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 881 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 882 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 883 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 884 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 885 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 886 printIdKey                    = mkPreludeMiscIdUnique 43
 887 failIOIdKey                   = mkPreludeMiscIdUnique 44
 888 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
 889 voidArgIdKey                  = mkPreludeMiscIdUnique 47
 890 splitIdKey                    = mkPreludeMiscIdUnique 48
 891 fstIdKey                      = mkPreludeMiscIdUnique 49
 892 sndIdKey                      = mkPreludeMiscIdUnique 50
 893 otherwiseIdKey                = mkPreludeMiscIdUnique 51
 894 assertIdKey                   = mkPreludeMiscIdUnique 53
 895 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
 896
 897 rootMainKey                   = mkPreludeMiscIdUnique 55
 898 runMainKey                    = mkPreludeMiscIdUnique 56
 899
 900 andIdKey                      = mkPreludeMiscIdUnique 57
 901 orIdKey                       = mkPreludeMiscIdUnique 58
 902 thenIOIdKey                   = mkPreludeMiscIdUnique 59
 903 lazyIdKey                     = mkPreludeMiscIdUnique 60
 904 assertErrorIdKey              = mkPreludeMiscIdUnique 61
 905
 906 -- Parallel array functions
 907 nullPIdKey                    = mkPreludeMiscIdUnique 80
 908 lengthPIdKey                  = mkPreludeMiscIdUnique 81
 909 replicatePIdKey               = mkPreludeMiscIdUnique 82
 910 mapPIdKey                     = mkPreludeMiscIdUnique 83
 911 filterPIdKey                  = mkPreludeMiscIdUnique 84
 912 zipPIdKey                     = mkPreludeMiscIdUnique 85
 913 crossPIdKey                   = mkPreludeMiscIdUnique 86
 914 indexPIdKey                   = mkPreludeMiscIdUnique 87
 915 toPIdKey                      = mkPreludeMiscIdUnique 88
 916 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
 917 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
 918 bpermutePIdKey                = mkPreludeMiscIdUnique 91
 919 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
 920 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
 921
 922 -- dotnet interop
 923 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
 924 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
 925 marshalStringIdKey            = mkPreludeMiscIdUnique 96
 926 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
 927 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
 928
 929 \end{code}
 930
 931 Certain class operations from Prelude classes.  They get their own
 932 uniques so we can look them up easily when we want to conjure them up
 933 during type checking.
 934
 935 \begin{code}
 936         -- Just a place holder for  unbound variables  produced by the renamer:
 937 unboundKey                    = mkPreludeMiscIdUnique 101
 938
 939 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
 940 minusClassOpKey               = mkPreludeMiscIdUnique 103
 941 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
 942 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
 943 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
 944 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
 945 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
 946 eqClassOpKey                  = mkPreludeMiscIdUnique 109
 947 geClassOpKey                  = mkPreludeMiscIdUnique 110
 948 negateClassOpKey              = mkPreludeMiscIdUnique 111
 949 failMClassOpKey               = mkPreludeMiscIdUnique 112
 950 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
 951 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
 952 returnMClassOpKey             = mkPreludeMiscIdUnique 117
 953
 954 -- Recursive do notation
 955 mfixIdKey       = mkPreludeMiscIdUnique 118
 956
 957 -- Arrow notation
 958 arrAIdKey       = mkPreludeMiscIdUnique 119
 959 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
 960 firstAIdKey     = mkPreludeMiscIdUnique 121
 961 appAIdKey       = mkPreludeMiscIdUnique 122
 962 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
 963 loopAIdKey      = mkPreludeMiscIdUnique 124
 964
 965 ---------------- Template Haskell -------------------
 966 --      USES IdUniques 200-399
 967 -----------------------------------------------------
 968 \end{code}
 969
 970
 971 %************************************************************************
 972 %*                                                                      *
 973 \subsection{Standard groups of types}
 974 %*                                                                      *
 975 %************************************************************************
 976
 977 \begin{code}
 978 numericTyKeys =
 979         [ addrTyConKey
 980         , wordTyConKey
 981         , intTyConKey
 982         , integerTyConKey
 983         , doubleTyConKey
 984         , floatTyConKey
 985         ]
 986
 987         -- Renamer always imports these data decls replete with constructors
 988         -- so that desugarer can always see their constructors.  Ugh!
 989 cCallishTyKeys =
 990         [ addrTyConKey
 991         , wordTyConKey
 992         , byteArrayTyConKey
 993         , mutableByteArrayTyConKey
 994         , stablePtrTyConKey
 995         , int8TyConKey
 996         , int16TyConKey
 997         , int32TyConKey
 998         , int64TyConKey
 999         , word8TyConKey
1000         , word16TyConKey
1001         , word32TyConKey
1002         , word64TyConKey
1003         ]
1004 \end{code}
1005
1006
1007 %************************************************************************
1008 %*                                                                      *
1009 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1010 %*                                                                      *
1011 %************************************************************************
1012
1013 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1014 even though every numeric class has these two as a superclass,
1015 because the list of ambiguous dictionaries hasn't been simplified.
1016
1017 \begin{code}
1018 numericClassKeys =
1019         [ numClassKey
1020         , realClassKey
1021         , integralClassKey
1022         ]
1023         ++ fractionalClassKeys
1024
1025 fractionalClassKeys =
1026         [ fractionalClassKey
1027         , floatingClassKey
1028         , realFracClassKey
1029         , realFloatClassKey
1030         ]
1031
1032         -- the strictness analyser needs to know about numeric types
1033         -- (see SaAbsInt.lhs)
1034 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1035         [ readClassKey
1036         ]
1037
1038 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1039 -- and are: "classes defined in the Prelude or a standard library"
1040 standardClassKeys = derivableClassKeys ++ numericClassKeys
1041                   ++ [randomClassKey, randomGenClassKey,
1042                       functorClassKey,
1043                       monadClassKey, monadPlusClassKey]
1044
1045 noDictClassKeys = [] -- ToDo: remove?
1046 \end{code}
1047
1048 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1049 (@TcDeriv@).
1050
1051 \begin{code}
1052 derivableClassKeys
1053   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1054       boundedClassKey, showClassKey, readClassKey ]
1055 \end{code}
1056