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