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 #if __GLASGOW_HASKELL__ < 405
 378         bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes }
 379 #else
 380         bytes = case chars62 of { BYTE_ARRAY _ _ bytes -> bytes }
 381 #endif
 382     in
 383     if n# <# 62# then
 384         case (indexCharArray# bytes n#) of { c ->
 385         char (C# c) }
 386     else
 387         case (quotRem n 62)             of { (q, I# r#) ->
 388         case (indexCharArray# bytes r#) of { c  ->
 389         (<>) (iToBase62 q) (char (C# c)) }}
 390
 391 -- keep this at top level! (bug on 94/10/24 WDP)
 392 chars62 :: BYTE_ARRAY Int
 393 chars62
 394   = RUN_ST (
 395         newCharArray (0, 61)    AND_THEN \ ch_array ->
 396         fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 397                                 AND_THEN_
 398         unsafeFreezeByteArray ch_array
 399     )
 400   where
 401     fill_in ch_array i lim str
 402       | i == lim
 403       = RETURN ()
 404       | otherwise
 405       = writeCharArray ch_array i (str !! i)    AND_THEN_
 406         fill_in ch_array (i+1) lim str
 407 \end{code}
 408
 409 %************************************************************************
 410 %*                                                                      *
 411 \subsection[Uniques-prelude]{@Uniques@ for wired-in Prelude things}
 412 %*                                                                      *
 413 %************************************************************************
 414
 415 Allocation of unique supply characters:
 416         v,t,u : for renumbering value-, type- and usage- vars.
 417         other a-z: lower case chars for unique supplies (see Main.lhs)
 418         B:   builtin
 419         C-E: pseudo uniques     (used in native-code generator)
 420         X:   uniques derived by deriveUnique
 421         _:   unifiable tyvars   (above)
 422         0-9: prelude things below
 423
 424 \begin{code}
 425 mkAlphaTyVarUnique i            = mkUnique '1' i
 426
 427 mkPreludeClassUnique i          = mkUnique '2' i
 428 mkPreludeTyConUnique i          = mkUnique '3' i
 429 mkTupleTyConUnique a            = mkUnique '4' a
 430 mkUbxTupleTyConUnique a         = mkUnique '5' a
 431
 432 mkPreludeDataConUnique i        = mkUnique '6' i -- must be alphabetic
 433 mkTupleDataConUnique a          = mkUnique '7' a -- ditto (*may* be used in C labels)
 434 mkUbxTupleDataConUnique a       = mkUnique '8' a
 435
 436 mkPrimOpIdUnique op             = mkUnique '9' op
 437 mkPreludeMiscIdUnique i         = mkUnique '0' i
 438
 439 -- The "tyvar uniques" print specially nicely: a, b, c, etc.
 440 -- See pprUnique for details
 441
 442 initTyVarUnique :: Unique
 443 initTyVarUnique = mkUnique 't' 0
 444
 445 initTidyUniques :: (Unique, Unique)     -- Global and local
 446 initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
 447
 448 mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
 449  mkBuiltinUnique :: Int -> Unique
 450
 451 mkBuiltinUnique i = mkUnique 'B' i
 452 mkPseudoUnique1 i = mkUnique 'C' i -- used for getUnique on Regs
 453 mkPseudoUnique2 i = mkUnique 'D' i -- ditto
 454 mkPseudoUnique3 i = mkUnique 'E' i -- ditto
 455
 456 getBuiltinUniques :: Int -> [Unique]
 457 getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
 458 \end{code}
 459
 460 %************************************************************************
 461 %*                                                                      *
 462 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 463 %*                                                                      *
 464 %************************************************************************
 465
 466 \begin{code}
 467 boundedClassKey         = mkPreludeClassUnique 1
 468 enumClassKey            = mkPreludeClassUnique 2
 469 eqClassKey              = mkPreludeClassUnique 3
 470 floatingClassKey        = mkPreludeClassUnique 5
 471 fractionalClassKey      = mkPreludeClassUnique 6
 472 integralClassKey        = mkPreludeClassUnique 7
 473 monadClassKey           = mkPreludeClassUnique 8
 474 monadPlusClassKey       = mkPreludeClassUnique 9
 475 functorClassKey         = mkPreludeClassUnique 10
 476 numClassKey             = mkPreludeClassUnique 11
 477 ordClassKey             = mkPreludeClassUnique 12
 478 readClassKey            = mkPreludeClassUnique 13
 479 realClassKey            = mkPreludeClassUnique 14
 480 realFloatClassKey       = mkPreludeClassUnique 15
 481 realFracClassKey        = mkPreludeClassUnique 16
 482 showClassKey            = mkPreludeClassUnique 17
 483
 484 cCallableClassKey       = mkPreludeClassUnique 18
 485 cReturnableClassKey     = mkPreludeClassUnique 19
 486
 487 ixClassKey              = mkPreludeClassUnique 20
 488 \end{code}
 489
 490 %************************************************************************
 491 %*                                                                      *
 492 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 493 %*                                                                      *
 494 %************************************************************************
 495
 496 \begin{code}
 497 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 498 addrTyConKey                            = mkPreludeTyConUnique  2
 499 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 500 boolTyConKey                            = mkPreludeTyConUnique  4
 501 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 502 charPrimTyConKey                        = mkPreludeTyConUnique  7
 503 charTyConKey                            = mkPreludeTyConUnique  8
 504 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 505 doubleTyConKey                          = mkPreludeTyConUnique 10
 506 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 507 floatTyConKey                           = mkPreludeTyConUnique 12
 508 funTyConKey                             = mkPreludeTyConUnique 13
 509 intPrimTyConKey                         = mkPreludeTyConUnique 14
 510 intTyConKey                             = mkPreludeTyConUnique 15
 511 int8TyConKey                            = mkPreludeTyConUnique 16
 512 int16TyConKey                           = mkPreludeTyConUnique 17
 513 int32TyConKey                           = mkPreludeTyConUnique 18
 514 int64PrimTyConKey                       = mkPreludeTyConUnique 19
 515 int64TyConKey                           = mkPreludeTyConUnique 20
 516 integerTyConKey                         = mkPreludeTyConUnique 21
 517 listTyConKey                            = mkPreludeTyConUnique 22
 518 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 23
 519 foreignObjTyConKey                      = mkPreludeTyConUnique 24
 520 weakPrimTyConKey                        = mkPreludeTyConUnique 25
 521 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 26
 522 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 27
 523 orderingTyConKey                        = mkPreludeTyConUnique 28
 524 mVarPrimTyConKey                        = mkPreludeTyConUnique 29
 525 ratioTyConKey                           = mkPreludeTyConUnique 30
 526 rationalTyConKey                        = mkPreludeTyConUnique 31
 527 realWorldTyConKey                       = mkPreludeTyConUnique 32
 528 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 33
 529 stablePtrTyConKey                       = mkPreludeTyConUnique 34
 530 statePrimTyConKey                       = mkPreludeTyConUnique 35
 531 stableNamePrimTyConKey                  = mkPreludeTyConUnique 50
 532 stableNameTyConKey                      = mkPreludeTyConUnique 51
 533 mutableByteArrayTyConKey                = mkPreludeTyConUnique 52
 534 mutVarPrimTyConKey                      = mkPreludeTyConUnique 53
 535 ioTyConKey                              = mkPreludeTyConUnique 55
 536 byteArrayTyConKey                       = mkPreludeTyConUnique 56
 537 wordPrimTyConKey                        = mkPreludeTyConUnique 57
 538 wordTyConKey                            = mkPreludeTyConUnique 58
 539 word8TyConKey                           = mkPreludeTyConUnique 59
 540 word16TyConKey                          = mkPreludeTyConUnique 60
 541 word32TyConKey                          = mkPreludeTyConUnique 61
 542 word64PrimTyConKey                      = mkPreludeTyConUnique 62
 543 word64TyConKey                          = mkPreludeTyConUnique 63
 544 boxedConKey                             = mkPreludeTyConUnique 64
 545 unboxedConKey                           = mkPreludeTyConUnique 65
 546 anyBoxConKey                            = mkPreludeTyConUnique 66
 547 kindConKey                              = mkPreludeTyConUnique 67
 548 boxityConKey                            = mkPreludeTyConUnique 68
 549 typeConKey                              = mkPreludeTyConUnique 69
 550 threadIdPrimTyConKey                    = mkPreludeTyConUnique 70
 551 \end{code}
 552
 553 %************************************************************************
 554 %*                                                                      *
 555 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 556 %*                                                                      *
 557 %************************************************************************
 558
 559 \begin{code}
 560 addrDataConKey                          = mkPreludeDataConUnique  1
 561 charDataConKey                          = mkPreludeDataConUnique  2
 562 consDataConKey                          = mkPreludeDataConUnique  3
 563 doubleDataConKey                        = mkPreludeDataConUnique  4
 564 falseDataConKey                         = mkPreludeDataConUnique  5
 565 floatDataConKey                         = mkPreludeDataConUnique  6
 566 intDataConKey                           = mkPreludeDataConUnique  7
 567 smallIntegerDataConKey                  = mkPreludeDataConUnique 12
 568 largeIntegerDataConKey                  = mkPreludeDataConUnique 13
 569 foreignObjDataConKey                    = mkPreludeDataConUnique 14
 570 nilDataConKey                           = mkPreludeDataConUnique 15
 571 ratioDataConKey                         = mkPreludeDataConUnique 16
 572 stablePtrDataConKey                     = mkPreludeDataConUnique 17
 573 stableNameDataConKey                    = mkPreludeDataConUnique 18
 574 trueDataConKey                          = mkPreludeDataConUnique 34
 575 wordDataConKey                          = mkPreludeDataConUnique 35
 576 stDataConKey                            = mkPreludeDataConUnique 40
 577 ioDataConKey                            = mkPreludeDataConUnique 42
 578 \end{code}
 579
 580 %************************************************************************
 581 %*                                                                      *
 582 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 583 %*                                                                      *
 584 %************************************************************************
 585
 586 \begin{code}
 587 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 588 appendIdKey                   = mkPreludeMiscIdUnique  2
 589 augmentIdKey                  = mkPreludeMiscIdUnique  3
 590 buildIdKey                    = mkPreludeMiscIdUnique  4
 591 errorIdKey                    = mkPreludeMiscIdUnique  5
 592 foldlIdKey                    = mkPreludeMiscIdUnique  6
 593 foldrIdKey                    = mkPreludeMiscIdUnique  7
 594 recSelErrIdKey                = mkPreludeMiscIdUnique  8
 595 integerMinusOneIdKey          = mkPreludeMiscIdUnique  9
 596 integerPlusOneIdKey           = mkPreludeMiscIdUnique 10
 597 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 11
 598 integerZeroIdKey              = mkPreludeMiscIdUnique 12
 599 int2IntegerIdKey              = mkPreludeMiscIdUnique 13
 600 addr2IntegerIdKey             = mkPreludeMiscIdUnique 14
 601 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 15
 602 lexIdKey                      = mkPreludeMiscIdUnique 16
 603 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 17
 604 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
 605 packCStringIdKey              = mkPreludeMiscIdUnique 19
 606 parErrorIdKey                 = mkPreludeMiscIdUnique 20
 607 parIdKey                      = mkPreludeMiscIdUnique 21
 608 patErrorIdKey                 = mkPreludeMiscIdUnique 22
 609 realWorldPrimIdKey            = mkPreludeMiscIdUnique 23
 610 recConErrorIdKey              = mkPreludeMiscIdUnique 24
 611 recUpdErrorIdKey              = mkPreludeMiscIdUnique 25
 612 traceIdKey                    = mkPreludeMiscIdUnique 26
 613 unpackCString2IdKey           = mkPreludeMiscIdUnique 27
 614 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 28
 615 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 29
 616 unpackCStringIdKey            = mkPreludeMiscIdUnique 30
 617 ushowListIdKey                = mkPreludeMiscIdUnique 31
 618 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 619 concatIdKey                   = mkPreludeMiscIdUnique 33
 620 filterIdKey                   = mkPreludeMiscIdUnique 34
 621 zipIdKey                      = mkPreludeMiscIdUnique 35
 622 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 623 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 37
 624 makeStablePtrIdKey            = mkPreludeMiscIdUnique 38
 625 getTagIdKey                   = mkPreludeMiscIdUnique 39
 626 \end{code}
 627
 628 Certain class operations from Prelude classes.  They get their own
 629 uniques so we can look them up easily when we want to conjure them up
 630 during type checking.
 631
 632 \begin{code}
 633 fromIntClassOpKey             = mkPreludeMiscIdUnique 101
 634 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
 635 minusClassOpKey               = mkPreludeMiscIdUnique 103
 636 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
 637 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
 638 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
 639 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
 640 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
 641 eqClassOpKey                  = mkPreludeMiscIdUnique 109
 642 geClassOpKey                  = mkPreludeMiscIdUnique 110
 643 failMClassOpKey               = mkPreludeMiscIdUnique 112
 644 thenMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
 645         -- Just a place holder for  unbound variables  produced by the renamer:
 646 unboundKey                    = mkPreludeMiscIdUnique 114
 647 fromEnumClassOpKey            = mkPreludeMiscIdUnique 115
 648
 649 mainKey                       = mkPreludeMiscIdUnique 116
 650 returnMClassOpKey             = mkPreludeMiscIdUnique 117
 651 otherwiseIdKey                = mkPreludeMiscIdUnique 118
 652 toEnumClassOpKey              = mkPreludeMiscIdUnique 119
 653 mapIdKey                      = mkPreludeMiscIdUnique 120
 654 \end{code}
 655
 656 \begin{code}
 657 assertIdKey                   = mkPreludeMiscIdUnique 121
 658 runSTRepIdKey                 = mkPreludeMiscIdUnique 122
 659 \end{code}