ghc/compiler/basicTypes/Unique.lhs

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