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