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