ghc/compiler/basicTypes/Unique.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
   3 %
   4 \section[Unique]{The @Unique@ data type}
   5
   6 @Uniques@ are used to distinguish entities in the compiler (@Ids@,
   7 @Classes@, etc.) from each other.  Thus, @Uniques@ are the basic
   8 comparison key in the compiler.
   9
  10 If there is any single operation that needs to be fast, it is @Unique@
  11 comparison.  Unsurprisingly, there is quite a bit of huff-and-puff
  12 directed to that end.
  13
  14 Some of the other hair in this code is to be able to use a
  15 ``splittable @UniqueSupply@'' if requested/possible (not standard
  16 Haskell).
  17
  18 \begin{code}
  19 #include "HsVersions.h"
  20
  21 --<mkdependHS:friends> UniqSupply
  22
  23 module Unique (
  24         Unique, Uniquable(..),
  25         u2i,                            -- hack: used in UniqFM
  26
  27         pprUnique, pprUnique10, showUnique,
  28
  29         mkUnique,                       -- Used in UniqSupply
  30         mkUniqueGrimily,                -- Used in UniqSupply only!
  31
  32         incrUnique,                     -- Used for renumbering
  33         initTyVarUnique, mkTyVarUnique,
  34         initTidyUniques,
  35
  36         -- now all the built-in Uniques (and functions to make them)
  37         -- [the Oh-So-Wonderful Haskell module system wins again...]
  38         mkAlphaTyVarUnique,
  39         mkPrimOpIdUnique,
  40         mkTupleDataConUnique,
  41         mkTupleTyConUnique,
  42
  43         getBuiltinUniques, mkBuiltinUnique,
  44         mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
  45
  46         absentErrorIdKey,       -- alphabetical...
  47         addrDataConKey,
  48         addrPrimTyConKey,
  49         addrTyConKey,
  50         andandIdKey,
  51         appendIdKey,
  52         arrayPrimTyConKey,
  53         augmentIdKey,
  54         boolTyConKey,
  55         boundedClassKey,
  56         buildDataConKey,
  57         buildIdKey,
  58         byteArrayPrimTyConKey,
  59         cCallableClassKey,
  60         cReturnableClassKey,
  61         charDataConKey,
  62         charPrimTyConKey,
  63         charTyConKey,
  64         composeIdKey,
  65         consDataConKey,
  66         doubleDataConKey,
  67         doublePrimTyConKey,
  68         doubleTyConKey,
  69         enumClassKey,
  70         enumFromClassOpKey,
  71         enumFromThenClassOpKey,
  72         enumFromThenToClassOpKey,
  73         enumFromToClassOpKey,
  74         eqClassKey,
  75         eqClassOpKey,
  76         eqDataConKey,
  77         errorIdKey,
  78         evalClassKey,
  79         falseDataConKey,
  80         floatDataConKey,
  81         floatPrimTyConKey,
  82         floatTyConKey,
  83         floatingClassKey,
  84         foldlIdKey,
  85         foldrIdKey,
  86         foreignObjDataConKey,
  87         foreignObjPrimTyConKey,
  88         foreignObjTyConKey,
  89         forkIdKey,
  90         fractionalClassKey,
  91         fromEnumClassOpKey,
  92         fromIntClassOpKey,
  93         fromIntegerClassOpKey,
  94         fromRationalClassOpKey,
  95         funTyConKey,
  96         functorClassKey,
  97         geClassOpKey,
  98         gtDataConKey,
  99         intDataConKey,
 100         intPrimTyConKey,
 101         intTyConKey,
 102         integerDataConKey,
 103         integerMinusOneIdKey,
 104         integerPlusOneIdKey,
 105         integerPlusTwoIdKey,
 106         integerTyConKey,
 107         integerZeroIdKey,
 108         integralClassKey,
 109         irrefutPatErrorIdKey,
 110         ixClassKey,
 111         lexIdKey,
 112         liftDataConKey,
 113         liftTyConKey,
 114         listTyConKey,
 115         ltDataConKey,
 116         mainKey,
 117         minusClassOpKey,
 118         monadClassKey,
 119         monadPlusClassKey,
 120         monadZeroClassKey,
 121         mutableArrayPrimTyConKey,
 122         mutableByteArrayPrimTyConKey,
 123         nilDataConKey,
 124         noDefaultMethodErrorIdKey,
 125         nonExhaustiveGuardsErrorIdKey,
 126         nonExplicitMethodErrorIdKey,
 127         notIdKey,
 128         numClassKey,
 129         ordClassKey,
 130         orderingTyConKey,
 131         otherwiseIdKey,
 132         packCStringIdKey,
 133         parErrorIdKey,
 134         parIdKey,
 135         patErrorIdKey,
 136         ratioDataConKey,
 137         ratioTyConKey,
 138         rationalTyConKey,
 139         readClassKey,
 140         readParenIdKey,
 141         realClassKey,
 142         realFloatClassKey,
 143         realFracClassKey,
 144         realWorldPrimIdKey,
 145         realWorldTyConKey,
 146         recConErrorIdKey,
 147         recUpdErrorIdKey,
 148         return2GMPsDataConKey,
 149         return2GMPsTyConKey,
 150         returnIntAndGMPDataConKey,
 151         returnIntAndGMPTyConKey,
 152         returnMClassOpKey,
 153         runSTIdKey,
 154         seqIdKey,
 155         showClassKey,
 156         showParenIdKey,
 157         showSpaceIdKey,
 158         showStringIdKey,
 159         stTyConKey,
 160         stDataConKey,
 161         ioTyConKey,
 162         ioDataConKey,
 163         ioResultTyConKey,
 164         ioOkDataConKey,
 165         ioFailDataConKey,
 166         stablePtrDataConKey,
 167         stablePtrPrimTyConKey,
 168         stablePtrTyConKey,
 169         stateAndAddrPrimDataConKey,
 170         stateAndAddrPrimTyConKey,
 171         stateAndArrayPrimDataConKey,
 172         stateAndArrayPrimTyConKey,
 173         stateAndByteArrayPrimDataConKey,
 174         stateAndByteArrayPrimTyConKey,
 175         stateAndCharPrimDataConKey,
 176         stateAndCharPrimTyConKey,
 177         stateAndDoublePrimDataConKey,
 178         stateAndDoublePrimTyConKey,
 179         stateAndFloatPrimDataConKey,
 180         stateAndFloatPrimTyConKey,
 181         stateAndForeignObjPrimDataConKey,
 182         stateAndForeignObjPrimTyConKey,
 183         stateAndIntPrimDataConKey,
 184         stateAndIntPrimTyConKey,
 185         stateAndMutableArrayPrimDataConKey,
 186         stateAndMutableArrayPrimTyConKey,
 187         stateAndMutableByteArrayPrimDataConKey,
 188         stateAndMutableByteArrayPrimTyConKey,
 189         stateAndPtrPrimDataConKey,
 190         stateAndPtrPrimTyConKey,
 191         stateAndStablePtrPrimDataConKey,
 192         stateAndStablePtrPrimTyConKey,
 193         stateAndSynchVarPrimDataConKey,
 194         stateAndSynchVarPrimTyConKey,
 195         stateAndWordPrimDataConKey,
 196         stateAndWordPrimTyConKey,
 197         stateDataConKey,
 198         stRetDataConKey,
 199         statePrimTyConKey,
 200         stateTyConKey,
 201         stRetTyConKey,
 202         synchVarPrimTyConKey,
 203         thenMClassOpKey,
 204         toEnumClassOpKey,
 205         traceIdKey,
 206         trueDataConKey,
 207         unpackCString2IdKey,
 208         unpackCStringAppendIdKey,
 209         unpackCStringFoldrIdKey,
 210         unpackCStringIdKey,
 211         ureadListIdKey,
 212         ushowListIdKey,
 213         voidIdKey,
 214         voidTyConKey,
 215         wordDataConKey,
 216         wordPrimTyConKey,
 217         wordTyConKey,
 218         zeroClassOpKey
 219         , copyableIdKey
 220         , noFollowIdKey
 221         , parAtAbsIdKey
 222         , parAtForNowIdKey
 223         , parAtIdKey
 224         , parAtRelIdKey
 225         , parGlobalIdKey
 226         , parLocalIdKey
 227         , unboundKey
 228         , byteArrayTyConKey
 229         , mutableByteArrayTyConKey
 230         , allClassKey
 231     ) where
 232
 233 #if __GLASGOW_HASKELL__ <= 201
 234 import PreludeGlaST
 235 #else
 236 import GlaExts
 237 import ST
 238 import PrelBase ( Char(..), chr, ord )
 239 #endif
 240
 241 IMP_Ubiq(){-uitous-}
 242
 243 import Outputable
 244 import Pretty
 245 import Util
 246 \end{code}
 247
 248 %************************************************************************
 249 %*                                                                      *
 250 \subsection[Unique-type]{@Unique@ type and operations}
 251 %*                                                                      *
 252 %************************************************************************
 253
 254 The @Chars@ are ``tag letters'' that identify the @UniqueSupply@.
 255 Fast comparison is everything on @Uniques@:
 256
 257 \begin{code}
 258 data Unique = MkUnique Int#
 259
 260 class Uniquable a where
 261     uniqueOf :: a -> Unique
 262 \end{code}
 263
 264 \begin{code}
 265 u2i :: Unique -> FAST_INT
 266 u2i (MkUnique i) = i
 267 \end{code}
 268
 269 Now come the functions which construct uniques from their pieces, and vice versa.
 270 The stuff about unique *supplies* is handled further down this module.
 271
 272 \begin{code}
 273 mkUnique        :: Char -> Int -> Unique        -- Builds a unique from pieces
 274 unpkUnique      :: Unique -> (Char, Int)        -- The reverse
 275
 276 mkUniqueGrimily :: Int# -> Unique               -- A trap-door for UniqSupply
 277
 278 incrUnique      :: Unique -> Unique
 279 \end{code}
 280
 281
 282 \begin{code}
 283 mkUniqueGrimily x = MkUnique x
 284
 285 incrUnique (MkUnique i) = MkUnique (i +# 1#)
 286
 287 -- pop the Char in the top 8 bits of the Unique(Supply)
 288
 289 -- No 64-bit bugs here, as long as we have at least 32 bits. --JSM
 290
 291 w2i x = word2Int# x
 292 i2w x = int2Word# x
 293 i2w_s x = (x::Int#)
 294
 295 mkUnique (C# c) (I# i)
 296   = MkUnique (w2i (((i2w (ord# c)) `shiftL#` (i2w_s 24#)) `or#` (i2w i)))
 297
 298 unpkUnique (MkUnique u)
 299   = let
 300         tag = C# (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#))))
 301         i   = I#  (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-}))
 302     in
 303     (tag, i)
 304   where
 305     shiftr x y = shiftRA# x y
 306 \end{code}
 307
 308 %************************************************************************
 309 %*                                                                      *
 310 \subsection[Unique-instances]{Instance declarations for @Unique@}
 311 %*                                                                      *
 312 %************************************************************************
 313
 314 And the whole point (besides uniqueness) is fast equality.  We don't
 315 use `deriving' because we want {\em precise} control of ordering
 316 (equality on @Uniques@ is v common).
 317
 318 \begin{code}
 319 eqUnique (MkUnique u1) (MkUnique u2) = u1 ==# u2
 320 ltUnique (MkUnique u1) (MkUnique u2) = u1 <#  u2
 321 leUnique (MkUnique u1) (MkUnique u2) = u1 <=# u2
 322
 323 cmpUnique (MkUnique u1) (MkUnique u2)
 324   = if u1 ==# u2 then EQ_ else if u1 <# u2 then LT_ else GT_
 325
 326 instance Eq Unique where
 327     a == b = eqUnique a b
 328     a /= b = not (eqUnique a b)
 329
 330 instance Ord Unique where
 331     a  < b = ltUnique a b
 332     a <= b = leUnique a b
 333     a  > b = not (leUnique a b)
 334     a >= b = not (ltUnique a b)
 335     _tagCmp a b = case cmpUnique a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
 336
 337 instance Ord3 Unique where
 338     cmp = cmpUnique
 339
 340 -----------------
 341 instance Uniquable Unique where
 342     uniqueOf u = u
 343 \end{code}
 344
 345 We do sometimes make strings with @Uniques@ in them:
 346 \begin{code}
 347 pprUnique, pprUnique10 :: Unique -> Doc
 348
 349 pprUnique uniq
 350   = case unpkUnique uniq of
 351       (tag, u) -> finish_ppr tag u (iToBase62 u)
 352
 353 pprUnique10 uniq        -- in base-10, dudes
 354   = case unpkUnique uniq of
 355       (tag, u) -> finish_ppr tag u (int u)
 356
 357 finish_ppr 't' u pp_u | u < 26
 358   =     -- Special case to make v common tyvars, t1, t2, ...
 359         -- come out as a, b, ... (shorter, easier to read)
 360     char (chr (ord 'a' + u))
 361 finish_ppr tag u pp_u = char tag <> pp_u
 362
 363 showUnique :: Unique -> String
 364 showUnique uniq = show (pprUnique uniq)
 365
 366 instance Outputable Unique where
 367     ppr sty u = pprUnique u
 368
 369 instance Text Unique where
 370     showsPrec p uniq rest = showUnique uniq
 371 \end{code}
 372
 373 %************************************************************************
 374 %*                                                                      *
 375 \subsection[Utils-base62]{Base-62 numbers}
 376 %*                                                                      *
 377 %************************************************************************
 378
 379 A character-stingy way to read/write numbers (notably Uniques).
 380 The ``62-its'' are \tr{[0-9a-zA-Z]}.  We don't handle negative Ints.
 381 Code stolen from Lennart.
 382 \begin{code}
 383 #if __GLASGOW_HASKELL__ == 201
 384 # define BYTE_ARRAY GHCbase.ByteArray
 385 # define RUN_ST     GHCbase.runST
 386 # define AND_THEN   >>=
 387 # define AND_THEN_  >>
 388 # define RETURN     return
 389 #elif __GLASGOW_HASKELL__ >= 202
 390 # define BYTE_ARRAY GlaExts.ByteArray
 391 # define RUN_ST     ST.runST
 392 # define AND_THEN   >>=
 393 # define AND_THEN_  >>
 394 # define RETURN     return
 395 #else
 396 # define BYTE_ARRAY _ByteArray
 397 # define RUN_ST     _runST
 398 # define AND_THEN   `thenStrictlyST`
 399 # define AND_THEN_  `seqStrictlyST`
 400 # define RETURN     returnStrictlyST
 401 #endif
 402
 403 iToBase62 :: Int -> Doc
 404
 405 iToBase62 n@(I# n#)
 406   = ASSERT(n >= 0)
 407     let
 408         bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes }
 409     in
 410     if n# <# 62# then
 411         case (indexCharArray# bytes n#) of { c ->
 412         char (C# c) }
 413     else
 414         case (quotRem n 62)             of { (q, I# r#) ->
 415         case (indexCharArray# bytes r#) of { c  ->
 416         (<>) (iToBase62 q) (char (C# c)) }}
 417
 418 -- keep this at top level! (bug on 94/10/24 WDP)
 419 chars62 :: BYTE_ARRAY Int
 420 chars62
 421   = RUN_ST (
 422         newCharArray (0, 61)    AND_THEN \ ch_array ->
 423         fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 424                                 AND_THEN_
 425         unsafeFreezeByteArray ch_array
 426     )
 427   where
 428     fill_in ch_array i lim str
 429       | i == lim
 430       = RETURN ()
 431       | otherwise
 432       = writeCharArray ch_array i (str !! i)    AND_THEN_
 433         fill_in ch_array (i+1) lim str
 434 \end{code}
 435
 436 %************************************************************************
 437 %*                                                                      *
 438 \subsection[Uniques-prelude]{@Uniques@ for wired-in Prelude things}
 439 %*                                                                      *
 440 %************************************************************************
 441
 442 Allocation of unique supply characters:
 443         v,t,u : for renumbering value-, type- and usage- vars.
 444         other a-z: lower case chars for unique supplies (see Main.lhs)
 445         B:   builtin
 446         C-E: pseudo uniques     (used in native-code generator)
 447         _:   unifiable tyvars   (above)
 448         1-8: prelude things below
 449
 450 \begin{code}
 451 mkAlphaTyVarUnique i            = mkUnique '1' i
 452
 453 mkPreludeClassUnique i          = mkUnique '2' i
 454 mkPreludeTyConUnique i          = mkUnique '3' i
 455 mkTupleTyConUnique a            = mkUnique '4' a
 456
 457 mkPreludeDataConUnique i        = mkUnique '5' i        -- must be alphabetic
 458 mkTupleDataConUnique a          = mkUnique '6' a        -- ditto (*may* be used in C labels)
 459
 460 mkPrimOpIdUnique op             = mkUnique '7' op
 461 mkPreludeMiscIdUnique i         = mkUnique '8' i
 462
 463 -- The "tyvar uniques" print specially nicely: a, b, c, etc.
 464 -- See pprUnique for details
 465
 466 initTyVarUnique :: Unique
 467 initTyVarUnique = mkUnique 't' 0
 468
 469 mkTyVarUnique :: Int -> Unique
 470 mkTyVarUnique n = mkUnique 't' n
 471
 472 initTidyUniques :: (Unique, Unique)     -- Global and local
 473 initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
 474
 475 mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
 476  mkBuiltinUnique :: Int -> Unique
 477
 478 mkBuiltinUnique i = mkUnique 'B' i
 479 mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs
 480 mkPseudoUnique2 i = mkUnique 'D' i -- ditto
 481 mkPseudoUnique3 i = mkUnique 'E' i -- ditto
 482
 483 getBuiltinUniques :: Int -> [Unique]
 484 getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
 485 \end{code}
 486
 487 %************************************************************************
 488 %*                                                                      *
 489 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 490 %*                                                                      *
 491 %************************************************************************
 492
 493 \begin{code}
 494 boundedClassKey         = mkPreludeClassUnique 1
 495 enumClassKey            = mkPreludeClassUnique 2
 496 eqClassKey              = mkPreludeClassUnique 3
 497 evalClassKey            = mkPreludeClassUnique 4
 498 floatingClassKey        = mkPreludeClassUnique 5
 499 fractionalClassKey      = mkPreludeClassUnique 6
 500 integralClassKey        = mkPreludeClassUnique 7
 501 monadClassKey           = mkPreludeClassUnique 8
 502 monadZeroClassKey       = mkPreludeClassUnique 9
 503 monadPlusClassKey       = mkPreludeClassUnique 10
 504 functorClassKey         = mkPreludeClassUnique 11
 505 numClassKey             = mkPreludeClassUnique 12
 506 ordClassKey             = mkPreludeClassUnique 13
 507 readClassKey            = mkPreludeClassUnique 14
 508 realClassKey            = mkPreludeClassUnique 15
 509 realFloatClassKey       = mkPreludeClassUnique 16
 510 realFracClassKey        = mkPreludeClassUnique 17
 511 showClassKey            = mkPreludeClassUnique 18
 512
 513 cCallableClassKey       = mkPreludeClassUnique 19
 514 cReturnableClassKey     = mkPreludeClassUnique 20
 515
 516 ixClassKey              = mkPreludeClassUnique 21
 517 allClassKey             = mkPreludeClassUnique 22       -- Pseudo class used for universal quantification
 518 \end{code}
 519
 520 %************************************************************************
 521 %*                                                                      *
 522 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 523 %*                                                                      *
 524 %************************************************************************
 525
 526 \begin{code}
 527 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 528 addrTyConKey                            = mkPreludeTyConUnique  2
 529 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 530 boolTyConKey                            = mkPreludeTyConUnique  4
 531 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 532 charPrimTyConKey                        = mkPreludeTyConUnique  7
 533 charTyConKey                            = mkPreludeTyConUnique  8
 534 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 535 doubleTyConKey                          = mkPreludeTyConUnique 10
 536 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 537 floatTyConKey                           = mkPreludeTyConUnique 12
 538 funTyConKey                             = mkPreludeTyConUnique 13
 539 intPrimTyConKey                         = mkPreludeTyConUnique 14
 540 intTyConKey                             = mkPreludeTyConUnique 15
 541 integerTyConKey                         = mkPreludeTyConUnique 16
 542 liftTyConKey                            = mkPreludeTyConUnique 17
 543 listTyConKey                            = mkPreludeTyConUnique 18
 544 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 19
 545 foreignObjTyConKey                      = mkPreludeTyConUnique 20
 546 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 21
 547 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 22
 548 orderingTyConKey                        = mkPreludeTyConUnique 23
 549 synchVarPrimTyConKey                    = mkPreludeTyConUnique 24
 550 ratioTyConKey                           = mkPreludeTyConUnique 25
 551 rationalTyConKey                        = mkPreludeTyConUnique 26
 552 realWorldTyConKey                       = mkPreludeTyConUnique 27
 553 return2GMPsTyConKey                     = mkPreludeTyConUnique 28
 554 returnIntAndGMPTyConKey                 = mkPreludeTyConUnique 29
 555 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 30
 556 stablePtrTyConKey                       = mkPreludeTyConUnique 31
 557 stateAndAddrPrimTyConKey                = mkPreludeTyConUnique 32
 558 stateAndArrayPrimTyConKey               = mkPreludeTyConUnique 33
 559 stateAndByteArrayPrimTyConKey           = mkPreludeTyConUnique 34
 560 stateAndCharPrimTyConKey                = mkPreludeTyConUnique 35
 561 stateAndDoublePrimTyConKey              = mkPreludeTyConUnique 36
 562 stateAndFloatPrimTyConKey               = mkPreludeTyConUnique 37
 563 stateAndIntPrimTyConKey                 = mkPreludeTyConUnique 38
 564 stateAndForeignObjPrimTyConKey          = mkPreludeTyConUnique 39
 565 stateAndMutableArrayPrimTyConKey        = mkPreludeTyConUnique 40
 566 stateAndMutableByteArrayPrimTyConKey    = mkPreludeTyConUnique 41
 567 stateAndSynchVarPrimTyConKey            = mkPreludeTyConUnique 42
 568 stateAndPtrPrimTyConKey                 = mkPreludeTyConUnique 43
 569 stateAndStablePtrPrimTyConKey           = mkPreludeTyConUnique 44
 570 stateAndWordPrimTyConKey                = mkPreludeTyConUnique 45
 571 statePrimTyConKey                       = mkPreludeTyConUnique 46
 572 stateTyConKey                           = mkPreludeTyConUnique 47
 573 mutableByteArrayTyConKey                = mkPreludeTyConUnique 48
 574 stTyConKey                              = mkPreludeTyConUnique 49
 575 stRetTyConKey                           = mkPreludeTyConUnique 50
 576 ioTyConKey                              = mkPreludeTyConUnique 51
 577 ioResultTyConKey                        = mkPreludeTyConUnique 52
 578 byteArrayTyConKey                       = mkPreludeTyConUnique 53
 579 wordPrimTyConKey                        = mkPreludeTyConUnique 54
 580 wordTyConKey                            = mkPreludeTyConUnique 55
 581 voidTyConKey                            = mkPreludeTyConUnique 56
 582 \end{code}
 583
 584 %************************************************************************
 585 %*                                                                      *
 586 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 587 %*                                                                      *
 588 %************************************************************************
 589
 590 \begin{code}
 591 addrDataConKey                          = mkPreludeDataConUnique  1
 592 buildDataConKey                         = mkPreludeDataConUnique  2
 593 charDataConKey                          = mkPreludeDataConUnique  4
 594 consDataConKey                          = mkPreludeDataConUnique  5
 595 doubleDataConKey                        = mkPreludeDataConUnique  6
 596 eqDataConKey                            = mkPreludeDataConUnique  7
 597 falseDataConKey                         = mkPreludeDataConUnique  8
 598 floatDataConKey                         = mkPreludeDataConUnique  9
 599 gtDataConKey                            = mkPreludeDataConUnique 10
 600 intDataConKey                           = mkPreludeDataConUnique 11
 601 integerDataConKey                       = mkPreludeDataConUnique 12
 602 liftDataConKey                          = mkPreludeDataConUnique 13
 603 ltDataConKey                            = mkPreludeDataConUnique 14
 604 foreignObjDataConKey                    = mkPreludeDataConUnique 15
 605 nilDataConKey                           = mkPreludeDataConUnique 18
 606 ratioDataConKey                         = mkPreludeDataConUnique 21
 607 return2GMPsDataConKey                   = mkPreludeDataConUnique 22
 608 returnIntAndGMPDataConKey               = mkPreludeDataConUnique 23
 609 stablePtrDataConKey                     = mkPreludeDataConUnique 24
 610 stateAndAddrPrimDataConKey              = mkPreludeDataConUnique 25
 611 stateAndArrayPrimDataConKey             = mkPreludeDataConUnique 26
 612 stateAndByteArrayPrimDataConKey         = mkPreludeDataConUnique 27
 613 stateAndCharPrimDataConKey              = mkPreludeDataConUnique 28
 614 stateAndDoublePrimDataConKey            = mkPreludeDataConUnique 29
 615 stateAndFloatPrimDataConKey             = mkPreludeDataConUnique 30
 616 stateAndIntPrimDataConKey               = mkPreludeDataConUnique 31
 617 stateAndForeignObjPrimDataConKey        = mkPreludeDataConUnique 32
 618 stateAndMutableArrayPrimDataConKey      = mkPreludeDataConUnique 33
 619 stateAndMutableByteArrayPrimDataConKey  = mkPreludeDataConUnique 34
 620 stateAndSynchVarPrimDataConKey          = mkPreludeDataConUnique 35
 621 stateAndPtrPrimDataConKey               = mkPreludeDataConUnique 36
 622 stateAndStablePtrPrimDataConKey         = mkPreludeDataConUnique 37
 623 stateAndWordPrimDataConKey              = mkPreludeDataConUnique 38
 624 stateDataConKey                         = mkPreludeDataConUnique 39
 625 trueDataConKey                          = mkPreludeDataConUnique 40
 626 wordDataConKey                          = mkPreludeDataConUnique 41
 627 stDataConKey                            = mkPreludeDataConUnique 42
 628 stRetDataConKey                         = mkPreludeDataConUnique 43
 629 ioDataConKey                            = mkPreludeDataConUnique 44
 630 ioOkDataConKey                          = mkPreludeDataConUnique 45
 631 ioFailDataConKey                        = mkPreludeDataConUnique 46
 632 \end{code}
 633
 634 %************************************************************************
 635 %*                                                                      *
 636 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 637 %*                                                                      *
 638 %************************************************************************
 639
 640 \begin{code}
 641 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 642 andandIdKey                   = mkPreludeMiscIdUnique  2
 643 appendIdKey                   = mkPreludeMiscIdUnique  3
 644 augmentIdKey                  = mkPreludeMiscIdUnique  4
 645 buildIdKey                    = mkPreludeMiscIdUnique  5
 646 composeIdKey                  = mkPreludeMiscIdUnique  6
 647 errorIdKey                    = mkPreludeMiscIdUnique  7
 648 foldlIdKey                    = mkPreludeMiscIdUnique  8
 649 foldrIdKey                    = mkPreludeMiscIdUnique  9
 650 forkIdKey                     = mkPreludeMiscIdUnique 10
 651 int2IntegerIdKey              = mkPreludeMiscIdUnique 11
 652 integerMinusOneIdKey          = mkPreludeMiscIdUnique 12
 653 integerPlusOneIdKey           = mkPreludeMiscIdUnique 13
 654 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 14
 655 integerZeroIdKey              = mkPreludeMiscIdUnique 15
 656 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 657 lexIdKey                      = mkPreludeMiscIdUnique 17
 658 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 20
 659 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
 660 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 22
 661 notIdKey                      = mkPreludeMiscIdUnique 23
 662 packCStringIdKey              = mkPreludeMiscIdUnique 24
 663 parErrorIdKey                 = mkPreludeMiscIdUnique 25
 664 parIdKey                      = mkPreludeMiscIdUnique 26
 665 patErrorIdKey                 = mkPreludeMiscIdUnique 27
 666 readParenIdKey                = mkPreludeMiscIdUnique 28
 667 realWorldPrimIdKey            = mkPreludeMiscIdUnique 29
 668 recConErrorIdKey              = mkPreludeMiscIdUnique 30
 669 recUpdErrorIdKey              = mkPreludeMiscIdUnique 31
 670 runSTIdKey                    = mkPreludeMiscIdUnique 32
 671 seqIdKey                      = mkPreludeMiscIdUnique 33
 672 showParenIdKey                = mkPreludeMiscIdUnique 34
 673 showSpaceIdKey                = mkPreludeMiscIdUnique 35
 674 showStringIdKey               = mkPreludeMiscIdUnique 36
 675 traceIdKey                    = mkPreludeMiscIdUnique 37
 676 unpackCString2IdKey           = mkPreludeMiscIdUnique 38
 677 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 39
 678 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 40
 679 unpackCStringIdKey            = mkPreludeMiscIdUnique 41
 680 voidIdKey                     = mkPreludeMiscIdUnique 42
 681 ushowListIdKey                = mkPreludeMiscIdUnique 43
 682 ureadListIdKey                = mkPreludeMiscIdUnique 44
 683
 684 copyableIdKey           = mkPreludeMiscIdUnique 45
 685 noFollowIdKey           = mkPreludeMiscIdUnique 46
 686 parAtAbsIdKey           = mkPreludeMiscIdUnique 47
 687 parAtForNowIdKey        = mkPreludeMiscIdUnique 48
 688 parAtIdKey              = mkPreludeMiscIdUnique 49
 689 parAtRelIdKey           = mkPreludeMiscIdUnique 50
 690 parGlobalIdKey          = mkPreludeMiscIdUnique 51
 691 parLocalIdKey           = mkPreludeMiscIdUnique 52
 692 \end{code}
 693
 694 Certain class operations from Prelude classes.  They get
 695 their own uniques so we can look them up easily when we want
 696 to conjure them up during type checking.
 697 \begin{code}
 698 fromIntClassOpKey       = mkPreludeMiscIdUnique 53
 699 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 54
 700 minusClassOpKey         = mkPreludeMiscIdUnique 55
 701 fromRationalClassOpKey  = mkPreludeMiscIdUnique 56
 702 enumFromClassOpKey      = mkPreludeMiscIdUnique 57
 703 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 58
 704 enumFromToClassOpKey    = mkPreludeMiscIdUnique 59
 705 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 60
 706 eqClassOpKey            = mkPreludeMiscIdUnique 61
 707 geClassOpKey            = mkPreludeMiscIdUnique 62
 708 zeroClassOpKey          = mkPreludeMiscIdUnique 63
 709 thenMClassOpKey         = mkPreludeMiscIdUnique 64 -- (>>=)
 710 unboundKey              = mkPreludeMiscIdUnique 65      -- Just a place holder for unbound
 711                                                         -- variables produced by the renamer
 712 fromEnumClassOpKey      = mkPreludeMiscIdUnique 66
 713
 714 mainKey                 = mkPreludeMiscIdUnique 67
 715 returnMClassOpKey       = mkPreludeMiscIdUnique 68
 716 otherwiseIdKey          = mkPreludeMiscIdUnique 69
 717 toEnumClassOpKey        = mkPreludeMiscIdUnique 70
 718 \end{code}