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) -> ppBeside (ppChar tag) (iToBase62 u)
 327
 328 pprUnique10 uniq        -- in base-10, dudes
 329   = case unpkUnique uniq of
 330       (tag, u) -> ppBeside (ppChar tag) (ppInt u)
 331
 332 showUnique :: Unique -> FAST_STRING
 333 showUnique uniq = _PK_ (ppShow 80 (pprUnique uniq))
 334
 335 instance Outputable Unique where
 336     ppr sty u = pprUnique u
 337
 338 instance Text Unique where
 339     showsPrec p uniq rest = _UNPK_ (showUnique uniq)
 340 \end{code}
 341
 342 %************************************************************************
 343 %*                                                                      *
 344 \subsection[Utils-base62]{Base-62 numbers}
 345 %*                                                                      *
 346 %************************************************************************
 347
 348 A character-stingy way to read/write numbers (notably Uniques).
 349 The ``62-its'' are \tr{[0-9a-zA-Z]}.  We don't handle negative Ints.
 350 Code stolen from Lennart.
 351 \begin{code}
 352 iToBase62 :: Int -> Pretty
 353
 354 iToBase62 n@(I# n#)
 355   = ASSERT(n >= 0)
 356     let
 357         bytes = case chars62 of { _ByteArray bounds_who_needs_'em bytes -> bytes }
 358     in
 359     if n# <# 62# then
 360         case (indexCharArray# bytes n#) of { c ->
 361         ppChar (C# c) }
 362     else
 363         case (quotRem n 62)             of { (q, I# r#) ->
 364         case (indexCharArray# bytes r#) of { c  ->
 365         ppBeside (iToBase62 q) (ppChar (C# c)) }}
 366
 367 -- keep this at top level! (bug on 94/10/24 WDP)
 368 chars62 :: _ByteArray Int
 369 chars62
 370   = _runST (
 371         newCharArray (0, 61)    `thenStrictlyST` \ ch_array ->
 372         fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 373                                 `seqStrictlyST`
 374         unsafeFreezeByteArray ch_array
 375     )
 376   where
 377     fill_in ch_array i lim str
 378       | i == lim
 379       = returnStrictlyST ()
 380       | otherwise
 381       = writeCharArray ch_array i (str !! i)    `seqStrictlyST`
 382         fill_in ch_array (i+1) lim str
 383 \end{code}
 384
 385 %************************************************************************
 386 %*                                                                      *
 387 \subsection[Uniques-prelude]{@Uniques@ for wired-in Prelude things}
 388 %*                                                                      *
 389 %************************************************************************
 390
 391 Allocation of unique supply characters:
 392         v,t,u : for renumbering value-, type- and usage- vars.
 393         other a-z: lower case chars for unique supplies (see Main.lhs)
 394         B:   builtin
 395         C-E: pseudo uniques     (used in native-code generator)
 396         _:   unifiable tyvars   (above)
 397         1-8: prelude things below
 398
 399 \begin{code}
 400 mkAlphaTyVarUnique i            = mkUnique '1' i
 401
 402 mkPreludeClassUnique i          = mkUnique '2' i
 403 mkPreludeTyConUnique i          = mkUnique '3' i
 404 mkTupleTyConUnique a            = mkUnique '4' a
 405
 406 mkPreludeDataConUnique i        = mkUnique '5' i        -- must be alphabetic
 407 mkTupleDataConUnique a          = mkUnique '6' a        -- ditto (*may* be used in C labels)
 408
 409 mkPrimOpIdUnique op             = mkUnique '7' op
 410 mkPreludeMiscIdUnique i         = mkUnique '8' i
 411
 412 initRenumberingUniques = (mkUnique 'v' 1, mkUnique 't' 1, mkUnique 'u' 1)
 413
 414 mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
 415  mkBuiltinUnique :: Int -> Unique
 416
 417 mkBuiltinUnique i = mkUnique 'B' i
 418 mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs
 419 mkPseudoUnique2 i = mkUnique 'D' i -- ditto
 420 mkPseudoUnique3 i = mkUnique 'E' i -- ditto
 421
 422 getBuiltinUniques :: Int -> [Unique]
 423 getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
 424 \end{code}
 425
 426 %************************************************************************
 427 %*                                                                      *
 428 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 429 %*                                                                      *
 430 %************************************************************************
 431
 432 \begin{code}
 433 boundedClassKey         = mkPreludeClassUnique 1
 434 enumClassKey            = mkPreludeClassUnique 2
 435 eqClassKey              = mkPreludeClassUnique 3
 436 evalClassKey            = mkPreludeClassUnique 4
 437 floatingClassKey        = mkPreludeClassUnique 5
 438 fractionalClassKey      = mkPreludeClassUnique 6
 439 integralClassKey        = mkPreludeClassUnique 7
 440 monadClassKey           = mkPreludeClassUnique 8
 441 monadZeroClassKey       = mkPreludeClassUnique 9
 442 monadPlusClassKey       = mkPreludeClassUnique 10
 443 functorClassKey         = mkPreludeClassUnique 11
 444 numClassKey             = mkPreludeClassUnique 12
 445 ordClassKey             = mkPreludeClassUnique 13
 446 readClassKey            = mkPreludeClassUnique 14
 447 realClassKey            = mkPreludeClassUnique 15
 448 realFloatClassKey       = mkPreludeClassUnique 16
 449 realFracClassKey        = mkPreludeClassUnique 17
 450 showClassKey            = mkPreludeClassUnique 18
 451
 452 cCallableClassKey       = mkPreludeClassUnique 19
 453 cReturnableClassKey     = mkPreludeClassUnique 20
 454
 455 ixClassKey              = mkPreludeClassUnique 21
 456 \end{code}
 457
 458 %************************************************************************
 459 %*                                                                      *
 460 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 461 %*                                                                      *
 462 %************************************************************************
 463
 464 \begin{code}
 465 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 466 addrTyConKey                            = mkPreludeTyConUnique  2
 467 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 468 boolTyConKey                            = mkPreludeTyConUnique  4
 469 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 470 charPrimTyConKey                        = mkPreludeTyConUnique  7
 471 charTyConKey                            = mkPreludeTyConUnique  8
 472 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 473 doubleTyConKey                          = mkPreludeTyConUnique 10
 474 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 475 floatTyConKey                           = mkPreludeTyConUnique 12
 476 funTyConKey                             = mkPreludeTyConUnique 13
 477 iOTyConKey                              = mkPreludeTyConUnique 14
 478 intPrimTyConKey                         = mkPreludeTyConUnique 15
 479 intTyConKey                             = mkPreludeTyConUnique 16
 480 integerTyConKey                         = mkPreludeTyConUnique 17
 481 liftTyConKey                            = mkPreludeTyConUnique 18
 482 listTyConKey                            = mkPreludeTyConUnique 19
 483 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 20
 484 foreignObjTyConKey                      = mkPreludeTyConUnique 21
 485 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 22
 486 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 23
 487 orderingTyConKey                        = mkPreludeTyConUnique 24
 488 synchVarPrimTyConKey                    = mkPreludeTyConUnique 25
 489 ratioTyConKey                           = mkPreludeTyConUnique 26
 490 rationalTyConKey                        = mkPreludeTyConUnique 27
 491 realWorldTyConKey                       = mkPreludeTyConUnique 28
 492 return2GMPsTyConKey                     = mkPreludeTyConUnique 29
 493 returnIntAndGMPTyConKey                 = mkPreludeTyConUnique 30
 494 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 31
 495 stablePtrTyConKey                       = mkPreludeTyConUnique 32
 496 stateAndAddrPrimTyConKey                = mkPreludeTyConUnique 33
 497 stateAndArrayPrimTyConKey               = mkPreludeTyConUnique 34
 498 stateAndByteArrayPrimTyConKey           = mkPreludeTyConUnique 35
 499 stateAndCharPrimTyConKey                = mkPreludeTyConUnique 36
 500 stateAndDoublePrimTyConKey              = mkPreludeTyConUnique 37
 501 stateAndFloatPrimTyConKey               = mkPreludeTyConUnique 38
 502 stateAndIntPrimTyConKey                 = mkPreludeTyConUnique 39
 503 stateAndForeignObjPrimTyConKey          = mkPreludeTyConUnique 40
 504 stateAndMutableArrayPrimTyConKey        = mkPreludeTyConUnique 41
 505 stateAndMutableByteArrayPrimTyConKey    = mkPreludeTyConUnique 42
 506 stateAndSynchVarPrimTyConKey            = mkPreludeTyConUnique 43
 507 stateAndPtrPrimTyConKey                 = mkPreludeTyConUnique 44
 508 stateAndStablePtrPrimTyConKey           = mkPreludeTyConUnique 45
 509 stateAndWordPrimTyConKey                = mkPreludeTyConUnique 46
 510 statePrimTyConKey                       = mkPreludeTyConUnique 47
 511 stateTyConKey                           = mkPreludeTyConUnique 48
 512                                                                 -- 49 is spare
 513 stTyConKey                              = mkPreludeTyConUnique 50
 514 primIoTyConKey                          = mkPreludeTyConUnique 51
 515                                                                 -- 52 is spare
 516 wordPrimTyConKey                        = mkPreludeTyConUnique 53
 517 wordTyConKey                            = mkPreludeTyConUnique 54
 518 voidTyConKey                            = mkPreludeTyConUnique 55
 519 \end{code}
 520
 521 %************************************************************************
 522 %*                                                                      *
 523 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 524 %*                                                                      *
 525 %************************************************************************
 526
 527 \begin{code}
 528 addrDataConKey                          = mkPreludeDataConUnique  1
 529 buildDataConKey                         = mkPreludeDataConUnique  2
 530 charDataConKey                          = mkPreludeDataConUnique  4
 531 consDataConKey                          = mkPreludeDataConUnique  5
 532 doubleDataConKey                        = mkPreludeDataConUnique  6
 533 eqDataConKey                            = mkPreludeDataConUnique  7
 534 falseDataConKey                         = mkPreludeDataConUnique  8
 535 floatDataConKey                         = mkPreludeDataConUnique  9
 536 gtDataConKey                            = mkPreludeDataConUnique 10
 537 intDataConKey                           = mkPreludeDataConUnique 11
 538 integerDataConKey                       = mkPreludeDataConUnique 12
 539 liftDataConKey                          = mkPreludeDataConUnique 13
 540 ltDataConKey                            = mkPreludeDataConUnique 14
 541 foreignObjDataConKey                    = mkPreludeDataConUnique 15
 542 nilDataConKey                           = mkPreludeDataConUnique 18
 543 ratioDataConKey                         = mkPreludeDataConUnique 21
 544 return2GMPsDataConKey                   = mkPreludeDataConUnique 22
 545 returnIntAndGMPDataConKey               = mkPreludeDataConUnique 23
 546 stablePtrDataConKey                     = mkPreludeDataConUnique 24
 547 stateAndAddrPrimDataConKey              = mkPreludeDataConUnique 25
 548 stateAndArrayPrimDataConKey             = mkPreludeDataConUnique 26
 549 stateAndByteArrayPrimDataConKey         = mkPreludeDataConUnique 27
 550 stateAndCharPrimDataConKey              = mkPreludeDataConUnique 28
 551 stateAndDoublePrimDataConKey            = mkPreludeDataConUnique 29
 552 stateAndFloatPrimDataConKey             = mkPreludeDataConUnique 30
 553 stateAndIntPrimDataConKey               = mkPreludeDataConUnique 31
 554 stateAndForeignObjPrimDataConKey        = mkPreludeDataConUnique 32
 555 stateAndMutableArrayPrimDataConKey      = mkPreludeDataConUnique 33
 556 stateAndMutableByteArrayPrimDataConKey  = mkPreludeDataConUnique 34
 557 stateAndSynchVarPrimDataConKey          = mkPreludeDataConUnique 35
 558 stateAndPtrPrimDataConKey               = mkPreludeDataConUnique 36
 559 stateAndStablePtrPrimDataConKey         = mkPreludeDataConUnique 37
 560 stateAndWordPrimDataConKey              = mkPreludeDataConUnique 38
 561 stateDataConKey                         = mkPreludeDataConUnique 39
 562 trueDataConKey                          = mkPreludeDataConUnique 40
 563 wordDataConKey                          = mkPreludeDataConUnique 41
 564 stDataConKey                            = mkPreludeDataConUnique 42
 565 primIoDataConKey                        = mkPreludeDataConUnique 43
 566 \end{code}
 567
 568 %************************************************************************
 569 %*                                                                      *
 570 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 571 %*                                                                      *
 572 %************************************************************************
 573
 574 \begin{code}
 575 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 576 andandIdKey                   = mkPreludeMiscIdUnique  2
 577 appendIdKey                   = mkPreludeMiscIdUnique  3
 578 augmentIdKey                  = mkPreludeMiscIdUnique  4
 579 buildIdKey                    = mkPreludeMiscIdUnique  5
 580 composeIdKey                  = mkPreludeMiscIdUnique  6
 581 errorIdKey                    = mkPreludeMiscIdUnique  7
 582 foldlIdKey                    = mkPreludeMiscIdUnique  8
 583 foldrIdKey                    = mkPreludeMiscIdUnique  9
 584 forkIdKey                     = mkPreludeMiscIdUnique 10
 585 int2IntegerIdKey              = mkPreludeMiscIdUnique 11
 586 integerMinusOneIdKey          = mkPreludeMiscIdUnique 12
 587 integerPlusOneIdKey           = mkPreludeMiscIdUnique 13
 588 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 14
 589 integerZeroIdKey              = mkPreludeMiscIdUnique 15
 590 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 591 lexIdKey                      = mkPreludeMiscIdUnique 17
 592 mainIdKey                     = mkPreludeMiscIdUnique 18
 593 mainPrimIOIdKey               = mkPreludeMiscIdUnique 19
 594 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 20
 595 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
 596 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 22
 597 notIdKey                      = mkPreludeMiscIdUnique 23
 598 packCStringIdKey              = mkPreludeMiscIdUnique 24
 599 parErrorIdKey                 = mkPreludeMiscIdUnique 25
 600 parIdKey                      = mkPreludeMiscIdUnique 26
 601 patErrorIdKey                 = mkPreludeMiscIdUnique 27
 602 readParenIdKey                = mkPreludeMiscIdUnique 28
 603 realWorldPrimIdKey            = mkPreludeMiscIdUnique 29
 604 recConErrorIdKey              = mkPreludeMiscIdUnique 30
 605 recUpdErrorIdKey              = mkPreludeMiscIdUnique 31
 606 runSTIdKey                    = mkPreludeMiscIdUnique 32
 607 seqIdKey                      = mkPreludeMiscIdUnique 33
 608 showParenIdKey                = mkPreludeMiscIdUnique 34
 609 showSpaceIdKey                = mkPreludeMiscIdUnique 35
 610 showStringIdKey               = mkPreludeMiscIdUnique 36
 611 traceIdKey                    = mkPreludeMiscIdUnique 37
 612 unpackCString2IdKey           = mkPreludeMiscIdUnique 38
 613 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 39
 614 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 40
 615 unpackCStringIdKey            = mkPreludeMiscIdUnique 41
 616 voidIdKey                     = mkPreludeMiscIdUnique 42
 617 ushowListIdKey                = mkPreludeMiscIdUnique 43
 618 ureadListIdKey                = mkPreludeMiscIdUnique 44
 619
 620 copyableIdKey           = mkPreludeMiscIdUnique 45
 621 noFollowIdKey           = mkPreludeMiscIdUnique 46
 622 parAtAbsIdKey           = mkPreludeMiscIdUnique 47
 623 parAtForNowIdKey        = mkPreludeMiscIdUnique 48
 624 parAtIdKey              = mkPreludeMiscIdUnique 49
 625 parAtRelIdKey           = mkPreludeMiscIdUnique 50
 626 parGlobalIdKey          = mkPreludeMiscIdUnique 51
 627 parLocalIdKey           = mkPreludeMiscIdUnique 52
 628 \end{code}
 629
 630 Certain class operations from Prelude classes.  They get
 631 their own uniques so we can look them up easily when we want
 632 to conjure them up during type checking.
 633 \begin{code}
 634 fromIntClassOpKey       = mkPreludeMiscIdUnique 53
 635 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 54
 636 fromRationalClassOpKey  = mkPreludeMiscIdUnique 55
 637 enumFromClassOpKey      = mkPreludeMiscIdUnique 56
 638 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 57
 639 enumFromToClassOpKey    = mkPreludeMiscIdUnique 58
 640 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59
 641 eqClassOpKey            = mkPreludeMiscIdUnique 60
 642 geClassOpKey            = mkPreludeMiscIdUnique 61
 643 zeroClassOpKey          = mkPreludeMiscIdUnique 62
 644 thenMClassOpKey         = mkPreludeMiscIdUnique 63 -- (>>=)
 645 \end{code}