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