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