ghc/compiler/basicTypes/Unique.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
   3 %
   4 \section[Unique]{The @Unique@ data type}
   5
   6 @Uniques@ are used to distinguish entities in the compiler (@Ids@,
   7 @Classes@, etc.) from each other.  Thus, @Uniques@ are the basic
   8 comparison key in the compiler.
   9
  10 If there is any single operation that needs to be fast, it is @Unique@
  11 comparison.  Unsurprisingly, there is quite a bit of huff-and-puff
  12 directed to that end.
  13
  14 Some of the other hair in this code is to be able to use a
  15 ``splittable @UniqueSupply@'' if requested/possible (not standard
  16 Haskell).
  17
  18 \begin{code}
  19 module Unique (
  20         Unique, Uniquable(..),
  21         u2i,                            -- hack: used in UniqFM
  22
  23         pprUnique, pprUnique10, showUnique,
  24
  25         mkUnique,                       -- Used in UniqSupply
  26         mkUniqueGrimily,                -- Used in UniqSupply only!
  27
  28         incrUnique,                     -- Used for renumbering
  29         initTyVarUnique, mkTyVarUnique,
  30         initTidyUniques,
  31
  32         -- now all the built-in Uniques (and functions to make them)
  33         -- [the Oh-So-Wonderful Haskell module system wins again...]
  34         mkAlphaTyVarUnique,
  35         mkPrimOpIdUnique,
  36         mkTupleDataConUnique,
  37         mkTupleTyConUnique,
  38
  39         getBuiltinUniques, mkBuiltinUnique,
  40         mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
  41
  42         absentErrorIdKey,       -- alphabetical...
  43         addrDataConKey,
  44         addrPrimTyConKey,
  45         addrTyConKey,
  46         andandIdKey,
  47         appendIdKey,
  48         arrayPrimTyConKey,
  49         augmentIdKey,
  50         boolTyConKey,
  51         boundedClassKey,
  52         buildDataConKey,
  53         buildIdKey,
  54         byteArrayPrimTyConKey,
  55         cCallableClassKey,
  56         cReturnableClassKey,
  57         charDataConKey,
  58         charPrimTyConKey,
  59         charTyConKey,
  60         composeIdKey,
  61         consDataConKey,
  62         doubleDataConKey,
  63         doublePrimTyConKey,
  64         doubleTyConKey,
  65         enumClassKey,
  66         enumFromClassOpKey,
  67         enumFromThenClassOpKey,
  68         enumFromThenToClassOpKey,
  69         enumFromToClassOpKey,
  70         eqClassKey,
  71         eqClassOpKey,
  72         eqDataConKey,
  73         errorIdKey,
  74         evalClassKey,
  75         falseDataConKey,
  76         floatDataConKey,
  77         floatPrimTyConKey,
  78         floatTyConKey,
  79         floatingClassKey,
  80         foldlIdKey,
  81         foldrIdKey,
  82         foreignObjDataConKey,
  83         foreignObjPrimTyConKey,
  84         foreignObjTyConKey,
  85         forkIdKey,
  86         fractionalClassKey,
  87         fromEnumClassOpKey,
  88         fromIntClassOpKey,
  89         fromIntegerClassOpKey,
  90         fromRationalClassOpKey,
  91         funTyConKey,
  92         functorClassKey,
  93         geClassOpKey,
  94         gtDataConKey,
  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         noDefaultMethodErrorIdKey,
 121         nonExhaustiveGuardsErrorIdKey,
 122         nonExplicitMethodErrorIdKey,
 123         notIdKey,
 124         numClassKey,
 125         ordClassKey,
 126         orderingTyConKey,
 127         otherwiseIdKey,
 128         packCStringIdKey,
 129         parErrorIdKey,
 130         parIdKey,
 131         patErrorIdKey,
 132         ratioDataConKey,
 133         ratioTyConKey,
 134         rationalTyConKey,
 135         readClassKey,
 136         readParenIdKey,
 137         realClassKey,
 138         realFloatClassKey,
 139         realFracClassKey,
 140         realWorldPrimIdKey,
 141         realWorldTyConKey,
 142         recConErrorIdKey,
 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 int2IntegerIdKey              = 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 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 20
 650 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
 651 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 22
 652 notIdKey                      = mkPreludeMiscIdUnique 23
 653 packCStringIdKey              = mkPreludeMiscIdUnique 24
 654 parErrorIdKey                 = mkPreludeMiscIdUnique 25
 655 parIdKey                      = mkPreludeMiscIdUnique 26
 656 patErrorIdKey                 = mkPreludeMiscIdUnique 27
 657 readParenIdKey                = mkPreludeMiscIdUnique 28
 658 realWorldPrimIdKey            = mkPreludeMiscIdUnique 29
 659 recConErrorIdKey              = mkPreludeMiscIdUnique 30
 660 recUpdErrorIdKey              = mkPreludeMiscIdUnique 31
 661 seqIdKey                      = mkPreludeMiscIdUnique 33
 662 showParenIdKey                = mkPreludeMiscIdUnique 34
 663 showSpaceIdKey                = mkPreludeMiscIdUnique 35
 664 showStringIdKey               = mkPreludeMiscIdUnique 36
 665 traceIdKey                    = mkPreludeMiscIdUnique 37
 666 unpackCString2IdKey           = mkPreludeMiscIdUnique 38
 667 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 39
 668 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 40
 669 unpackCStringIdKey            = mkPreludeMiscIdUnique 41
 670 voidIdKey                     = mkPreludeMiscIdUnique 42
 671 ushowListIdKey                = mkPreludeMiscIdUnique 43
 672 ureadListIdKey                = mkPreludeMiscIdUnique 44
 673
 674 copyableIdKey           = mkPreludeMiscIdUnique 45
 675 noFollowIdKey           = mkPreludeMiscIdUnique 46
 676 parAtAbsIdKey           = mkPreludeMiscIdUnique 47
 677 parAtForNowIdKey        = mkPreludeMiscIdUnique 48
 678 parAtIdKey              = mkPreludeMiscIdUnique 49
 679 parAtRelIdKey           = mkPreludeMiscIdUnique 50
 680 parGlobalIdKey          = mkPreludeMiscIdUnique 51
 681 parLocalIdKey           = mkPreludeMiscIdUnique 52
 682 \end{code}
 683
 684 Certain class operations from Prelude classes.  They get
 685 their own uniques so we can look them up easily when we want
 686 to conjure them up during type checking.
 687 \begin{code}
 688 fromIntClassOpKey       = mkPreludeMiscIdUnique 53
 689 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 54
 690 minusClassOpKey         = mkPreludeMiscIdUnique 55
 691 fromRationalClassOpKey  = mkPreludeMiscIdUnique 56
 692 enumFromClassOpKey      = mkPreludeMiscIdUnique 57
 693 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 58
 694 enumFromToClassOpKey    = mkPreludeMiscIdUnique 59
 695 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 60
 696 eqClassOpKey            = mkPreludeMiscIdUnique 61
 697 geClassOpKey            = mkPreludeMiscIdUnique 62
 698 zeroClassOpKey          = mkPreludeMiscIdUnique 63
 699 thenMClassOpKey         = mkPreludeMiscIdUnique 64 -- (>>=)
 700 unboundKey              = mkPreludeMiscIdUnique 65      -- Just a place holder for unbound
 701                                                         -- variables produced by the renamer
 702 fromEnumClassOpKey      = mkPreludeMiscIdUnique 66
 703
 704 mainKey                 = mkPreludeMiscIdUnique 67
 705 returnMClassOpKey       = mkPreludeMiscIdUnique 68
 706 otherwiseIdKey          = mkPreludeMiscIdUnique 69
 707 toEnumClassOpKey        = mkPreludeMiscIdUnique 70
 708 \end{code}