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