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