ghc/compiler/basicTypes/Unique.lhs

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