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