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