ghc/compiler/basicTypes/Unique.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4
   5 @Uniques@ are used to distinguish entities in the compiler (@Ids@,
   6 @Classes@, etc.) from each other.  Thus, @Uniques@ are the basic
   7 comparison key in the compiler.
   8
   9 If there is any single operation that needs to be fast, it is @Unique@
  10 comparison.  Unsurprisingly, there is quite a bit of huff-and-puff
  11 directed to that end.
  12
  13 Some of the other hair in this code is to be able to use a
  14 ``splittable @UniqueSupply@'' if requested/possible (not standard
  15 Haskell).
  16
  17 \begin{code}
  18 module Unique (
  19         Unique, Uniquable(..), hasKey,
  20         u2i,                            -- hack: used in UniqFM
  21
  22         pprUnique, pprUnique10,
  23
  24         mkUnique,                       -- Used in UniqSupply
  25         mkUniqueGrimily,                -- Used in UniqSupply only!
  26         getKey,                         -- Used in Var only!
  27
  28         incrUnique,                     -- Used for renumbering
  29         deriveUnique,                   -- Ditto
  30         initTyVarUnique,
  31         initTidyUniques,
  32
  33         isTupleKey,
  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         appendIdKey,
  50         arrayPrimTyConKey,
  51         assertIdKey,
  52         augmentIdKey,
  53         bcoPrimTyConKey,
  54         bindIOIdKey,
  55         boolTyConKey,
  56         boundedClassKey,
  57         boxedConKey,
  58         buildIdKey,
  59         byteArrayPrimTyConKey,
  60         byteArrayTyConKey,
  61         cCallableClassKey,
  62         cReturnableClassKey,
  63         charDataConKey,
  64         charPrimTyConKey,
  65         charTyConKey,
  66         concatIdKey,
  67         consDataConKey,
  68         deRefStablePtrIdKey,
  69         doubleDataConKey,
  70         doublePrimTyConKey,
  71         doubleTyConKey,
  72         enumClassKey,
  73         enumFromClassOpKey,
  74         enumFromThenClassOpKey,
  75         enumFromThenToClassOpKey,
  76         enumFromToClassOpKey,
  77         eqClassKey,
  78         eqClassOpKey,
  79         errorIdKey,
  80         falseDataConKey,
  81         failMClassOpKey,
  82         filterIdKey,
  83         floatDataConKey,
  84         floatPrimTyConKey,
  85         floatTyConKey,
  86         floatingClassKey,
  87         foldlIdKey,
  88         foldrIdKey,
  89         foreignObjDataConKey,
  90         foreignObjPrimTyConKey,
  91         foreignObjTyConKey,
  92         fractionalClassKey,
  93         fromEnumClassOpKey,
  94         fromIntClassOpKey,
  95         fromIntegerClassOpKey,
  96         fromRationalClassOpKey,
  97         funTyConKey,
  98         functorClassKey,
  99         geClassOpKey,
 100         getTagIdKey,
 101         intDataConKey,
 102         intPrimTyConKey,
 103         intTyConKey,
 104         int8TyConKey,
 105         int16TyConKey,
 106         int32TyConKey,
 107         int64PrimTyConKey,
 108         int64TyConKey,
 109         smallIntegerDataConKey,
 110         largeIntegerDataConKey,
 111         integerMinusOneIdKey,
 112         integerPlusOneIdKey,
 113         integerPlusTwoIdKey,
 114         int2IntegerIdKey,
 115         addr2IntegerIdKey,
 116         integerTyConKey,
 117         integerZeroIdKey,
 118         integralClassKey,
 119         irrefutPatErrorIdKey,
 120         ixClassKey,
 121         listTyConKey,
 122         mainKey,
 123         makeStablePtrIdKey,
 124         mapIdKey,
 125         minusClassOpKey,
 126         monadClassKey,
 127         monadPlusClassKey,
 128         mutableArrayPrimTyConKey,
 129         mutableByteArrayPrimTyConKey,
 130         mutableByteArrayTyConKey,
 131         mutVarPrimTyConKey,
 132         nilDataConKey,
 133         noMethodBindingErrorIdKey,
 134         nonExhaustiveGuardsErrorIdKey,
 135         numClassKey,
 136         anyBoxConKey,
 137         ordClassKey,
 138         orderingTyConKey,
 139         otherwiseIdKey,
 140         parErrorIdKey,
 141         parIdKey,
 142         patErrorIdKey,
 143         ratioDataConKey,
 144         ratioTyConKey,
 145         rationalTyConKey,
 146         readClassKey,
 147         realClassKey,
 148         realFloatClassKey,
 149         realFracClassKey,
 150         realWorldPrimIdKey,
 151         realWorldTyConKey,
 152         recConErrorIdKey,
 153         recSelErrIdKey,
 154         recUpdErrorIdKey,
 155         returnIOIdKey,
 156         returnMClassOpKey,
 157         runSTRepIdKey,
 158         showClassKey,
 159         ioTyConKey,
 160         ioDataConKey,
 161         stablePtrDataConKey,
 162         stablePtrPrimTyConKey,
 163         stablePtrTyConKey,
 164         stableNameDataConKey,
 165         stableNamePrimTyConKey,
 166         stableNameTyConKey,
 167
 168         statePrimTyConKey,
 169         typeConKey,
 170         kindConKey,
 171         boxityConKey,
 172         mVarPrimTyConKey,
 173         thenMClassOpKey,
 174         threadIdPrimTyConKey,
 175         toEnumClassOpKey,
 176         traceIdKey,
 177         trueDataConKey,
 178         unboundKey,
 179         unboxedConKey,
 180         unpackCString2IdKey,
 181         unpackCStringAppendIdKey,
 182         unpackCStringFoldrIdKey,
 183         unpackCStringIdKey,
 184         unsafeCoerceIdKey,
 185         ushowListIdKey,
 186         weakPrimTyConKey,
 187         wordDataConKey,
 188         wordPrimTyConKey,
 189         wordTyConKey,
 190         word8TyConKey,
 191         word16TyConKey,
 192         word32TyConKey,
 193         word64PrimTyConKey,
 194         word64TyConKey,
 195         zipIdKey
 196     ) where
 197
 198 #include "HsVersions.h"
 199
 200 import BasicTypes       ( Boxity(..) )
 201 import FastString       ( FastString, uniqueOfFS )
 202 import GlaExts
 203 import ST
 204 import PrelBase ( Char(..), chr, ord )
 205
 206 import Outputable
 207 \end{code}
 208
 209 %************************************************************************
 210 %*                                                                      *
 211 \subsection[Unique-type]{@Unique@ type and operations}
 212 %*                                                                      *
 213 %************************************************************************
 214
 215 The @Chars@ are ``tag letters'' that identify the @UniqueSupply@.
 216 Fast comparison is everything on @Uniques@:
 217
 218 \begin{code}
 219 data Unique = MkUnique Int#
 220 \end{code}
 221
 222 \begin{code}
 223 u2i :: Unique -> FAST_INT
 224 u2i (MkUnique i) = i
 225 \end{code}
 226
 227 Now come the functions which construct uniques from their pieces, and vice versa.
 228 The stuff about unique *supplies* is handled further down this module.
 229
 230 \begin{code}
 231 mkUnique        :: Char -> Int -> Unique        -- Builds a unique from pieces
 232 unpkUnique      :: Unique -> (Char, Int)        -- The reverse
 233
 234 mkUniqueGrimily :: Int# -> Unique               -- A trap-door for UniqSupply
 235
 236 getKey          :: Unique -> Int#               -- for Var
 237
 238 incrUnique      :: Unique -> Unique
 239 deriveUnique    :: Unique -> Int -> Unique
 240
 241 isTupleKey      :: Unique -> Bool
 242 \end{code}
 243
 244
 245 \begin{code}
 246 mkUniqueGrimily x = MkUnique x
 247
 248 {-# INLINE getKey #-}
 249 getKey (MkUnique x) = x
 250
 251 incrUnique (MkUnique i) = MkUnique (i +# 1#)
 252
 253 -- deriveUnique uses an 'X' tag so that it won't clash with
 254 -- any of the uniques produced any other way
 255 deriveUnique (MkUnique i) delta = mkUnique 'X' (I# i + delta)
 256
 257 -- pop the Char in the top 8 bits of the Unique(Supply)
 258
 259 -- No 64-bit bugs here, as long as we have at least 32 bits. --JSM
 260
 261 w2i x = word2Int# x
 262 i2w x = int2Word# x
 263 i2w_s x = (x::Int#)
 264
 265 mkUnique (C# c) (I# i)
 266   = MkUnique (w2i (tag `or#` bits))
 267   where
 268     tag  = i2w (ord# c) `shiftL#` i2w_s 24#
 269     bits = i2w i `and#` (i2w 16777215#){-``0x00ffffff''-}
 270
 271 unpkUnique (MkUnique u)
 272   = let
 273         tag = C# (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#))))
 274         i   = I# (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-}))
 275     in
 276     (tag, i)
 277   where
 278     shiftr x y = shiftRL# x y
 279 \end{code}
 280
 281
 282
 283 %************************************************************************
 284 %*                                                                      *
 285 \subsection[Uniquable-class]{The @Uniquable@ class}
 286 %*                                                                      *
 287 %************************************************************************
 288
 289 \begin{code}
 290 class Uniquable a where
 291     getUnique :: a -> Unique
 292
 293 hasKey          :: Uniquable a => a -> Unique -> Bool
 294 x `hasKey` k    = getUnique x == k
 295
 296 instance Uniquable FastString where
 297  getUnique fs = mkUniqueGrimily (uniqueOfFS fs)
 298
 299 instance Uniquable Int where
 300  getUnique (I# i#) = mkUniqueGrimily i#
 301 \end{code}
 302
 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     compare a b = cmpUnique a b
 332
 333 -----------------
 334 instance Uniquable Unique where
 335     getUnique u = u
 336 \end{code}
 337
 338 We do sometimes make strings with @Uniques@ in them:
 339 \begin{code}
 340 pprUnique, pprUnique10 :: Unique -> SDoc
 341
 342 pprUnique uniq
 343   = case unpkUnique uniq of
 344       (tag, u) -> finish_ppr tag u (iToBase62 u)
 345
 346 pprUnique10 uniq        -- in base-10, dudes
 347   = case unpkUnique uniq of
 348       (tag, u) -> finish_ppr tag u (int u)
 349
 350 finish_ppr 't' u pp_u | u < 26
 351   =     -- Special case to make v common tyvars, t1, t2, ...
 352         -- come out as a, b, ... (shorter, easier to read)
 353     char (chr (ord 'a' + u))
 354 finish_ppr tag u pp_u = char tag <> pp_u
 355
 356 instance Outputable Unique where
 357     ppr u = pprUnique u
 358
 359 instance Show Unique where
 360     showsPrec p uniq = showsPrecSDoc p (pprUnique uniq)
 361 \end{code}
 362
 363 %************************************************************************
 364 %*                                                                      *
 365 \subsection[Utils-base62]{Base-62 numbers}
 366 %*                                                                      *
 367 %************************************************************************
 368
 369 A character-stingy way to read/write numbers (notably Uniques).
 370 The ``62-its'' are \tr{[0-9a-zA-Z]}.  We don't handle negative Ints.
 371 Code stolen from Lennart.
 372 \begin{code}
 373 # define BYTE_ARRAY GlaExts.ByteArray
 374 # define RUN_ST     ST.runST
 375 # define AND_THEN   >>=
 376 # define AND_THEN_  >>
 377 # define RETURN     return
 378
 379 iToBase62 :: Int -> SDoc
 380
 381 iToBase62 n@(I# n#)
 382   = ASSERT(n >= 0)
 383     let
 384 #if __GLASGOW_HASKELL__ < 405
 385         bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes }
 386 #else
 387         bytes = case chars62 of { BYTE_ARRAY _ _ bytes -> bytes }
 388 #endif
 389     in
 390     if n# <# 62# then
 391         case (indexCharArray# bytes n#) of { c ->
 392         char (C# c) }
 393     else
 394         case (quotRem n 62)             of { (q, I# r#) ->
 395         case (indexCharArray# bytes r#) of { c  ->
 396         (<>) (iToBase62 q) (char (C# c)) }}
 397
 398 -- keep this at top level! (bug on 94/10/24 WDP)
 399 chars62 :: BYTE_ARRAY Int
 400 chars62
 401   = RUN_ST (
 402         newCharArray (0, 61)    AND_THEN \ ch_array ->
 403         fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 404                                 AND_THEN_
 405         unsafeFreezeByteArray ch_array
 406     )
 407   where
 408     fill_in ch_array i lim str
 409       | i == lim
 410       = RETURN ()
 411       | otherwise
 412       = writeCharArray ch_array i (str !! i)    AND_THEN_
 413         fill_in ch_array (i+1) lim str
 414 \end{code}
 415
 416 %************************************************************************
 417 %*                                                                      *
 418 \subsection[Uniques-prelude]{@Uniques@ for wired-in Prelude things}
 419 %*                                                                      *
 420 %************************************************************************
 421
 422 Allocation of unique supply characters:
 423         v,t,u : for renumbering value-, type- and usage- vars.
 424         other a-z: lower case chars for unique supplies (see Main.lhs)
 425         B:   builtin
 426         C-E: pseudo uniques     (used in native-code generator)
 427         X:   uniques derived by deriveUnique
 428         _:   unifiable tyvars   (above)
 429         0-9: prelude things below
 430
 431 \begin{code}
 432 mkAlphaTyVarUnique i            = mkUnique '1' i
 433
 434 mkPreludeClassUnique i          = mkUnique '2' i
 435 mkPreludeTyConUnique i          = mkUnique '3' i
 436 mkTupleTyConUnique Boxed   a    = mkUnique '4' a
 437 mkTupleTyConUnique Unboxed a    = mkUnique '5' a
 438
 439 -- Data constructor keys occupy *two* slots.  The first is used for the
 440 -- data constructor itself and its wrapper function (the function that
 441 -- evaluates arguments as necessary and calls the worker). The second is
 442 -- used for the worker function (the function that builds the constructor
 443 -- representation).
 444
 445 mkPreludeDataConUnique i        = mkUnique '6' (2*i)    -- Must be alphabetic
 446 mkTupleDataConUnique Boxed a    = mkUnique '7' (2*a)    -- ditto (*may* be used in C labels)
 447 mkTupleDataConUnique Unboxed a  = mkUnique '8' (2*a)
 448
 449 -- This one is used for a tiresome reason
 450 -- to improve a consistency-checking error check in the renamer
 451 isTupleKey u = case unpkUnique u of
 452                 (tag,_) -> tag == '4' || tag == '5' || tag == '7' || tag == '8'
 453
 454 mkPrimOpIdUnique op             = mkUnique '9' op
 455 mkPreludeMiscIdUnique i         = mkUnique '0' i
 456
 457 -- The "tyvar uniques" print specially nicely: a, b, c, etc.
 458 -- See pprUnique for details
 459
 460 initTyVarUnique :: Unique
 461 initTyVarUnique = mkUnique 't' 0
 462
 463 initTidyUniques :: (Unique, Unique)     -- Global and local
 464 initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
 465
 466 mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
 467    mkBuiltinUnique :: Int -> Unique
 468
 469 mkBuiltinUnique i = mkUnique 'B' i
 470 mkPseudoUnique1 i = mkUnique 'C' i -- used for getUnique on Regs
 471 mkPseudoUnique2 i = mkUnique 'D' i -- used in NCG for getUnique on RealRegs
 472 mkPseudoUnique3 i = mkUnique 'E' i -- used in NCG spiller to create spill VirtualRegs
 473
 474
 475
 476 getBuiltinUniques :: Int -> [Unique]
 477 getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
 478 \end{code}
 479
 480 %************************************************************************
 481 %*                                                                      *
 482 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 483 %*                                                                      *
 484 %************************************************************************
 485
 486 \begin{code}
 487 boundedClassKey         = mkPreludeClassUnique 1
 488 enumClassKey            = mkPreludeClassUnique 2
 489 eqClassKey              = mkPreludeClassUnique 3
 490 floatingClassKey        = mkPreludeClassUnique 5
 491 fractionalClassKey      = mkPreludeClassUnique 6
 492 integralClassKey        = mkPreludeClassUnique 7
 493 monadClassKey           = mkPreludeClassUnique 8
 494 monadPlusClassKey       = mkPreludeClassUnique 9
 495 functorClassKey         = mkPreludeClassUnique 10
 496 numClassKey             = mkPreludeClassUnique 11
 497 ordClassKey             = mkPreludeClassUnique 12
 498 readClassKey            = mkPreludeClassUnique 13
 499 realClassKey            = mkPreludeClassUnique 14
 500 realFloatClassKey       = mkPreludeClassUnique 15
 501 realFracClassKey        = mkPreludeClassUnique 16
 502 showClassKey            = mkPreludeClassUnique 17
 503
 504 cCallableClassKey       = mkPreludeClassUnique 18
 505 cReturnableClassKey     = mkPreludeClassUnique 19
 506
 507 ixClassKey              = mkPreludeClassUnique 20
 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 intPrimTyConKey                         = mkPreludeTyConUnique 14
 530 intTyConKey                             = mkPreludeTyConUnique 15
 531 int8TyConKey                            = mkPreludeTyConUnique 16
 532 int16TyConKey                           = mkPreludeTyConUnique 17
 533 int32TyConKey                           = mkPreludeTyConUnique 18
 534 int64PrimTyConKey                       = mkPreludeTyConUnique 19
 535 int64TyConKey                           = mkPreludeTyConUnique 20
 536 integerTyConKey                         = mkPreludeTyConUnique 21
 537 listTyConKey                            = mkPreludeTyConUnique 22
 538 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 23
 539 foreignObjTyConKey                      = mkPreludeTyConUnique 24
 540 weakPrimTyConKey                        = mkPreludeTyConUnique 25
 541 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 26
 542 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 27
 543 orderingTyConKey                        = mkPreludeTyConUnique 28
 544 mVarPrimTyConKey                        = mkPreludeTyConUnique 29
 545 ratioTyConKey                           = mkPreludeTyConUnique 30
 546 rationalTyConKey                        = mkPreludeTyConUnique 31
 547 realWorldTyConKey                       = mkPreludeTyConUnique 32
 548 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 33
 549 stablePtrTyConKey                       = mkPreludeTyConUnique 34
 550 statePrimTyConKey                       = mkPreludeTyConUnique 35
 551 stableNamePrimTyConKey                  = mkPreludeTyConUnique 50
 552 stableNameTyConKey                      = mkPreludeTyConUnique 51
 553 mutableByteArrayTyConKey                = mkPreludeTyConUnique 52
 554 mutVarPrimTyConKey                      = mkPreludeTyConUnique 53
 555 ioTyConKey                              = mkPreludeTyConUnique 55
 556 byteArrayTyConKey                       = mkPreludeTyConUnique 56
 557 wordPrimTyConKey                        = mkPreludeTyConUnique 57
 558 wordTyConKey                            = mkPreludeTyConUnique 58
 559 word8TyConKey                           = mkPreludeTyConUnique 59
 560 word16TyConKey                          = mkPreludeTyConUnique 60
 561 word32TyConKey                          = mkPreludeTyConUnique 61
 562 word64PrimTyConKey                      = mkPreludeTyConUnique 62
 563 word64TyConKey                          = mkPreludeTyConUnique 63
 564 boxedConKey                             = mkPreludeTyConUnique 64
 565 unboxedConKey                           = mkPreludeTyConUnique 65
 566 anyBoxConKey                            = mkPreludeTyConUnique 66
 567 kindConKey                              = mkPreludeTyConUnique 67
 568 boxityConKey                            = mkPreludeTyConUnique 68
 569 typeConKey                              = mkPreludeTyConUnique 69
 570 threadIdPrimTyConKey                    = mkPreludeTyConUnique 70
 571 bcoPrimTyConKey                         = mkPreludeTyConUnique 71
 572 \end{code}
 573
 574 %************************************************************************
 575 %*                                                                      *
 576 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 577 %*                                                                      *
 578 %************************************************************************
 579
 580 \begin{code}
 581 addrDataConKey                          = mkPreludeDataConUnique  0
 582 charDataConKey                          = mkPreludeDataConUnique  1
 583 consDataConKey                          = mkPreludeDataConUnique  2
 584 doubleDataConKey                        = mkPreludeDataConUnique  3
 585 falseDataConKey                         = mkPreludeDataConUnique  4
 586 floatDataConKey                         = mkPreludeDataConUnique  5
 587 intDataConKey                           = mkPreludeDataConUnique  6
 588 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 589 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 590 foreignObjDataConKey                    = mkPreludeDataConUnique  9
 591 nilDataConKey                           = mkPreludeDataConUnique 10
 592 ratioDataConKey                         = mkPreludeDataConUnique 11
 593 stablePtrDataConKey                     = mkPreludeDataConUnique 12
 594 stableNameDataConKey                    = mkPreludeDataConUnique 13
 595 trueDataConKey                          = mkPreludeDataConUnique 14
 596 wordDataConKey                          = mkPreludeDataConUnique 15
 597 stDataConKey                            = mkPreludeDataConUnique 16
 598 ioDataConKey                            = mkPreludeDataConUnique 17
 599 \end{code}
 600
 601 %************************************************************************
 602 %*                                                                      *
 603 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 604 %*                                                                      *
 605 %************************************************************************
 606
 607 \begin{code}
 608 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 609 appendIdKey                   = mkPreludeMiscIdUnique  2
 610 augmentIdKey                  = mkPreludeMiscIdUnique  3
 611 buildIdKey                    = mkPreludeMiscIdUnique  4
 612 errorIdKey                    = mkPreludeMiscIdUnique  5
 613 foldlIdKey                    = mkPreludeMiscIdUnique  6
 614 foldrIdKey                    = mkPreludeMiscIdUnique  7
 615 recSelErrIdKey                = mkPreludeMiscIdUnique  8
 616 integerMinusOneIdKey          = mkPreludeMiscIdUnique  9
 617 integerPlusOneIdKey           = mkPreludeMiscIdUnique 10
 618 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 11
 619 integerZeroIdKey              = mkPreludeMiscIdUnique 12
 620 int2IntegerIdKey              = mkPreludeMiscIdUnique 13
 621 addr2IntegerIdKey             = mkPreludeMiscIdUnique 14
 622 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 15
 623 lexIdKey                      = mkPreludeMiscIdUnique 16
 624 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 17
 625 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
 626 parErrorIdKey                 = mkPreludeMiscIdUnique 20
 627 parIdKey                      = mkPreludeMiscIdUnique 21
 628 patErrorIdKey                 = mkPreludeMiscIdUnique 22
 629 realWorldPrimIdKey            = mkPreludeMiscIdUnique 23
 630 recConErrorIdKey              = mkPreludeMiscIdUnique 24
 631 recUpdErrorIdKey              = mkPreludeMiscIdUnique 25
 632 traceIdKey                    = mkPreludeMiscIdUnique 26
 633 unpackCString2IdKey           = mkPreludeMiscIdUnique 27
 634 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 28
 635 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 29
 636 unpackCStringIdKey            = mkPreludeMiscIdUnique 30
 637 ushowListIdKey                = mkPreludeMiscIdUnique 31
 638 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 639 concatIdKey                   = mkPreludeMiscIdUnique 33
 640 filterIdKey                   = mkPreludeMiscIdUnique 34
 641 zipIdKey                      = mkPreludeMiscIdUnique 35
 642 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 643 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 644 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 645 makeStablePtrIdKey            = mkPreludeMiscIdUnique 39
 646 getTagIdKey                   = mkPreludeMiscIdUnique 40
 647 \end{code}
 648
 649 Certain class operations from Prelude classes.  They get their own
 650 uniques so we can look them up easily when we want to conjure them up
 651 during type checking.
 652
 653 \begin{code}
 654 fromIntClassOpKey             = mkPreludeMiscIdUnique 101
 655 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
 656 minusClassOpKey               = mkPreludeMiscIdUnique 103
 657 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
 658 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
 659 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
 660 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
 661 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
 662 eqClassOpKey                  = mkPreludeMiscIdUnique 109
 663 geClassOpKey                  = mkPreludeMiscIdUnique 110
 664 failMClassOpKey               = mkPreludeMiscIdUnique 112
 665 thenMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
 666         -- Just a place holder for  unbound variables  produced by the renamer:
 667 unboundKey                    = mkPreludeMiscIdUnique 114
 668 fromEnumClassOpKey            = mkPreludeMiscIdUnique 115
 669
 670 mainKey                       = mkPreludeMiscIdUnique 116
 671 returnMClassOpKey             = mkPreludeMiscIdUnique 117
 672 otherwiseIdKey                = mkPreludeMiscIdUnique 118
 673 toEnumClassOpKey              = mkPreludeMiscIdUnique 119
 674 mapIdKey                      = mkPreludeMiscIdUnique 120
 675 \end{code}
 676
 677 \begin{code}
 678 assertIdKey                   = mkPreludeMiscIdUnique 121
 679 runSTRepIdKey                 = mkPreludeMiscIdUnique 122
 680 \end{code}