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