ghc/compiler/basicTypes/Unique.lhs

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