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