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