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