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