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         mainIdKey,
 116         mainPrimIOIdKey,
 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         primIoDataConKey,
 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         runSTIdKey,
 153         seqIdKey,
 154         showClassKey,
 155         showParenIdKey,
 156         showSpaceIdKey,
 157         showStringIdKey,
 158         stTyConKey,
 159         stDataConKey,
 160         stablePtrDataConKey,
 161         stablePtrPrimTyConKey,
 162         stablePtrTyConKey,
 163         stateAndAddrPrimDataConKey,
 164         stateAndAddrPrimTyConKey,
 165         stateAndArrayPrimDataConKey,
 166         stateAndArrayPrimTyConKey,
 167         stateAndByteArrayPrimDataConKey,
 168         stateAndByteArrayPrimTyConKey,
 169         stateAndCharPrimDataConKey,
 170         stateAndCharPrimTyConKey,
 171         stateAndDoublePrimDataConKey,
 172         stateAndDoublePrimTyConKey,
 173         stateAndFloatPrimDataConKey,
 174         stateAndFloatPrimTyConKey,
 175         stateAndForeignObjPrimDataConKey,
 176         stateAndForeignObjPrimTyConKey,
 177         stateAndIntPrimDataConKey,
 178         stateAndIntPrimTyConKey,
 179         stateAndMutableArrayPrimDataConKey,
 180         stateAndMutableArrayPrimTyConKey,
 181         stateAndMutableByteArrayPrimDataConKey,
 182         stateAndMutableByteArrayPrimTyConKey,
 183         stateAndPtrPrimDataConKey,
 184         stateAndPtrPrimTyConKey,
 185         stateAndStablePtrPrimDataConKey,
 186         stateAndStablePtrPrimTyConKey,
 187         stateAndSynchVarPrimDataConKey,
 188         stateAndSynchVarPrimTyConKey,
 189         stateAndWordPrimDataConKey,
 190         stateAndWordPrimTyConKey,
 191         stateDataConKey,
 192         statePrimTyConKey,
 193         stateTyConKey,
 194         synchVarPrimTyConKey,
 195         thenMClassOpKey,
 196         traceIdKey,
 197         trueDataConKey,
 198         unpackCString2IdKey,
 199         unpackCStringAppendIdKey,
 200         unpackCStringFoldrIdKey,
 201         unpackCStringIdKey,
 202         ureadListIdKey,
 203         ushowListIdKey,
 204         voidIdKey,
 205         voidTyConKey,
 206         wordDataConKey,
 207         wordPrimTyConKey,
 208         wordTyConKey,
 209         zeroClassOpKey
 210         , copyableIdKey
 211         , noFollowIdKey
 212         , parAtAbsIdKey
 213         , parAtForNowIdKey
 214         , parAtIdKey
 215         , parAtRelIdKey
 216         , parGlobalIdKey
 217         , parLocalIdKey
 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 primIoDataConKey                        = mkPreludeDataConUnique 43
 594 \end{code}
 595
 596 %************************************************************************
 597 %*                                                                      *
 598 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 599 %*                                                                      *
 600 %************************************************************************
 601
 602 \begin{code}
 603 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 604 andandIdKey                   = mkPreludeMiscIdUnique  2
 605 appendIdKey                   = mkPreludeMiscIdUnique  3
 606 augmentIdKey                  = mkPreludeMiscIdUnique  4
 607 buildIdKey                    = mkPreludeMiscIdUnique  5
 608 composeIdKey                  = mkPreludeMiscIdUnique  6
 609 errorIdKey                    = mkPreludeMiscIdUnique  7
 610 foldlIdKey                    = mkPreludeMiscIdUnique  8
 611 foldrIdKey                    = mkPreludeMiscIdUnique  9
 612 forkIdKey                     = mkPreludeMiscIdUnique 10
 613 int2IntegerIdKey              = mkPreludeMiscIdUnique 11
 614 integerMinusOneIdKey          = mkPreludeMiscIdUnique 12
 615 integerPlusOneIdKey           = mkPreludeMiscIdUnique 13
 616 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 14
 617 integerZeroIdKey              = mkPreludeMiscIdUnique 15
 618 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 619 lexIdKey                      = mkPreludeMiscIdUnique 17
 620 mainIdKey                     = mkPreludeMiscIdUnique 18
 621 mainPrimIOIdKey               = mkPreludeMiscIdUnique 19
 622 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 20
 623 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
 624 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 22
 625 notIdKey                      = mkPreludeMiscIdUnique 23
 626 packCStringIdKey              = mkPreludeMiscIdUnique 24
 627 parErrorIdKey                 = mkPreludeMiscIdUnique 25
 628 parIdKey                      = mkPreludeMiscIdUnique 26
 629 patErrorIdKey                 = mkPreludeMiscIdUnique 27
 630 readParenIdKey                = mkPreludeMiscIdUnique 28
 631 realWorldPrimIdKey            = mkPreludeMiscIdUnique 29
 632 recConErrorIdKey              = mkPreludeMiscIdUnique 30
 633 recUpdErrorIdKey              = mkPreludeMiscIdUnique 31
 634 runSTIdKey                    = mkPreludeMiscIdUnique 32
 635 seqIdKey                      = mkPreludeMiscIdUnique 33
 636 showParenIdKey                = mkPreludeMiscIdUnique 34
 637 showSpaceIdKey                = mkPreludeMiscIdUnique 35
 638 showStringIdKey               = mkPreludeMiscIdUnique 36
 639 traceIdKey                    = mkPreludeMiscIdUnique 37
 640 unpackCString2IdKey           = mkPreludeMiscIdUnique 38
 641 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 39
 642 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 40
 643 unpackCStringIdKey            = mkPreludeMiscIdUnique 41
 644 voidIdKey                     = mkPreludeMiscIdUnique 42
 645 ushowListIdKey                = mkPreludeMiscIdUnique 43
 646 ureadListIdKey                = mkPreludeMiscIdUnique 44
 647
 648 copyableIdKey           = mkPreludeMiscIdUnique 45
 649 noFollowIdKey           = mkPreludeMiscIdUnique 46
 650 parAtAbsIdKey           = mkPreludeMiscIdUnique 47
 651 parAtForNowIdKey        = mkPreludeMiscIdUnique 48
 652 parAtIdKey              = mkPreludeMiscIdUnique 49
 653 parAtRelIdKey           = mkPreludeMiscIdUnique 50
 654 parGlobalIdKey          = mkPreludeMiscIdUnique 51
 655 parLocalIdKey           = mkPreludeMiscIdUnique 52
 656 \end{code}
 657
 658 Certain class operations from Prelude classes.  They get
 659 their own uniques so we can look them up easily when we want
 660 to conjure them up during type checking.
 661 \begin{code}
 662 fromIntClassOpKey       = mkPreludeMiscIdUnique 53
 663 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 54
 664 fromRationalClassOpKey  = mkPreludeMiscIdUnique 55
 665 enumFromClassOpKey      = mkPreludeMiscIdUnique 56
 666 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 57
 667 enumFromToClassOpKey    = mkPreludeMiscIdUnique 58
 668 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59
 669 eqClassOpKey            = mkPreludeMiscIdUnique 60
 670 geClassOpKey            = mkPreludeMiscIdUnique 61
 671 zeroClassOpKey          = mkPreludeMiscIdUnique 62
 672 thenMClassOpKey         = mkPreludeMiscIdUnique 63 -- (>>=)
 673 \end{code}