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