ghc/compiler/basicTypes/Unique.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
   3 %
   4 \section[Unique]{The @Unique@ data type}
   5
   6 @Uniques@ are used to distinguish entities in the compiler (@Ids@,
   7 @Classes@, etc.) from each other.  Thus, @Uniques@ are the basic
   8 comparison key in the compiler.
   9
  10 If there is any single operation that needs to be fast, it is @Unique@
  11 comparison.  Unsurprisingly, there is quite a bit of huff-and-puff
  12 directed to that end.
  13
  14 Some of the other hair in this code is to be able to use a
  15 ``splittable @UniqueSupply@'' if requested/possible (not standard
  16 Haskell).
  17
  18 \begin{code}
  19 #include "HsVersions.h"
  20
  21 --<mkdependHS:friends> UniqSupply
  22
  23 module Unique (
  24         Unique, Uniquable(..),
  25         u2i,                            -- hack: used in UniqFM
  26
  27         pprUnique, pprUnique10, showUnique,
  28
  29         mkUnique,                       -- Used in UniqSupply
  30         mkUniqueGrimily,                -- Used in UniqSupply only!
  31
  32         incrUnique,                     -- Used for renumbering
  33         initTyVarUnique, mkTyVarUnique,
  34         initTidyUniques,
  35
  36         -- now all the built-in Uniques (and functions to make them)
  37         -- [the Oh-So-Wonderful Haskell module system wins again...]
  38         mkAlphaTyVarUnique,
  39         mkPrimOpIdUnique,
  40         mkTupleDataConUnique,
  41         mkTupleTyConUnique,
  42
  43         getBuiltinUniques, mkBuiltinUnique,
  44         mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
  45
  46         absentErrorIdKey,       -- alphabetical...
  47         addrDataConKey,
  48         addrPrimTyConKey,
  49         addrTyConKey,
  50         andandIdKey,
  51         appendIdKey,
  52         arrayPrimTyConKey,
  53         augmentIdKey,
  54         boolTyConKey,
  55         boundedClassKey,
  56         buildDataConKey,
  57         buildIdKey,
  58         byteArrayPrimTyConKey,
  59         cCallableClassKey,
  60         cReturnableClassKey,
  61         charDataConKey,
  62         charPrimTyConKey,
  63         charTyConKey,
  64         composeIdKey,
  65         consDataConKey,
  66         doubleDataConKey,
  67         doublePrimTyConKey,
  68         doubleTyConKey,
  69         enumClassKey,
  70         enumFromClassOpKey,
  71         enumFromThenClassOpKey,
  72         enumFromThenToClassOpKey,
  73         enumFromToClassOpKey,
  74         eqClassKey,
  75         eqClassOpKey,
  76         eqDataConKey,
  77         errorIdKey,
  78         evalClassKey,
  79         falseDataConKey,
  80         floatDataConKey,
  81         floatPrimTyConKey,
  82         floatTyConKey,
  83         floatingClassKey,
  84         foldlIdKey,
  85         foldrIdKey,
  86         foreignObjDataConKey,
  87         foreignObjPrimTyConKey,
  88         foreignObjTyConKey,
  89         forkIdKey,
  90         fractionalClassKey,
  91         fromEnumClassOpKey,
  92         fromIntClassOpKey,
  93         fromIntegerClassOpKey,
  94         fromRationalClassOpKey,
  95         funTyConKey,
  96         functorClassKey,
  97         geClassOpKey,
  98         gtDataConKey,
  99         iOTyConKey,
 100         intDataConKey,
 101         intPrimTyConKey,
 102         intTyConKey,
 103         integerDataConKey,
 104         integerMinusOneIdKey,
 105         integerPlusOneIdKey,
 106         integerPlusTwoIdKey,
 107         integerTyConKey,
 108         integerZeroIdKey,
 109         integralClassKey,
 110         irrefutPatErrorIdKey,
 111         ixClassKey,
 112         lexIdKey,
 113         liftDataConKey,
 114         liftTyConKey,
 115         listTyConKey,
 116         ltDataConKey,
 117         mainKey, mainPrimIoKey,
 118         minusClassOpKey,
 119         monadClassKey,
 120         monadPlusClassKey,
 121         monadZeroClassKey,
 122         mutableArrayPrimTyConKey,
 123         mutableByteArrayPrimTyConKey,
 124         nilDataConKey,
 125         noDefaultMethodErrorIdKey,
 126         nonExhaustiveGuardsErrorIdKey,
 127         nonExplicitMethodErrorIdKey,
 128         notIdKey,
 129         numClassKey,
 130         ordClassKey,
 131         orderingTyConKey,
 132         otherwiseIdKey,
 133         packCStringIdKey,
 134         parErrorIdKey,
 135         parIdKey,
 136         patErrorIdKey,
 137         primIoTyConKey,
 138         ratioDataConKey,
 139         ratioTyConKey,
 140         rationalTyConKey,
 141         readClassKey,
 142         readParenIdKey,
 143         realClassKey,
 144         realFloatClassKey,
 145         realFracClassKey,
 146         realWorldPrimIdKey,
 147         realWorldTyConKey,
 148         recConErrorIdKey,
 149         recUpdErrorIdKey,
 150         return2GMPsDataConKey,
 151         return2GMPsTyConKey,
 152         returnIntAndGMPDataConKey,
 153         returnIntAndGMPTyConKey,
 154         returnMClassOpKey,
 155         runSTIdKey,
 156         seqIdKey,
 157         showClassKey,
 158         showParenIdKey,
 159         showSpaceIdKey,
 160         showStringIdKey,
 161         stTyConKey,
 162         stDataConKey,
 163         stablePtrDataConKey,
 164         stablePtrPrimTyConKey,
 165         stablePtrTyConKey,
 166         stateAndAddrPrimDataConKey,
 167         stateAndAddrPrimTyConKey,
 168         stateAndArrayPrimDataConKey,
 169         stateAndArrayPrimTyConKey,
 170         stateAndByteArrayPrimDataConKey,
 171         stateAndByteArrayPrimTyConKey,
 172         stateAndCharPrimDataConKey,
 173         stateAndCharPrimTyConKey,
 174         stateAndDoublePrimDataConKey,
 175         stateAndDoublePrimTyConKey,
 176         stateAndFloatPrimDataConKey,
 177         stateAndFloatPrimTyConKey,
 178         stateAndForeignObjPrimDataConKey,
 179         stateAndForeignObjPrimTyConKey,
 180         stateAndIntPrimDataConKey,
 181         stateAndIntPrimTyConKey,
 182         stateAndMutableArrayPrimDataConKey,
 183         stateAndMutableArrayPrimTyConKey,
 184         stateAndMutableByteArrayPrimDataConKey,
 185         stateAndMutableByteArrayPrimTyConKey,
 186         stateAndPtrPrimDataConKey,
 187         stateAndPtrPrimTyConKey,
 188         stateAndStablePtrPrimDataConKey,
 189         stateAndStablePtrPrimTyConKey,
 190         stateAndSynchVarPrimDataConKey,
 191         stateAndSynchVarPrimTyConKey,
 192         stateAndWordPrimDataConKey,
 193         stateAndWordPrimTyConKey,
 194         stateDataConKey,
 195         stRetDataConKey,
 196         statePrimTyConKey,
 197         stateTyConKey,
 198         stRetTyConKey,
 199         synchVarPrimTyConKey,
 200         thenMClassOpKey,
 201         toEnumClassOpKey,
 202         traceIdKey,
 203         trueDataConKey,
 204         unpackCString2IdKey,
 205         unpackCStringAppendIdKey,
 206         unpackCStringFoldrIdKey,
 207         unpackCStringIdKey,
 208         ureadListIdKey,
 209         ushowListIdKey,
 210         voidIdKey,
 211         voidTyConKey,
 212         wordDataConKey,
 213         wordPrimTyConKey,
 214         wordTyConKey,
 215         zeroClassOpKey
 216         , copyableIdKey
 217         , noFollowIdKey
 218         , parAtAbsIdKey
 219         , parAtForNowIdKey
 220         , parAtIdKey
 221         , parAtRelIdKey
 222         , parGlobalIdKey
 223         , parLocalIdKey
 224         , unboundKey
 225         , byteArrayTyConKey
 226         , mutableByteArrayTyConKey
 227         , allClassKey
 228     ) where
 229
 230 #if __GLASGOW_HASKELL__ <= 201
 231 import PreludeGlaST
 232 #else
 233 import GlaExts
 234 import ST
 235 import PrelBase ( Char(..), chr, ord )
 236 #endif
 237
 238 IMP_Ubiq(){-uitous-}
 239
 240 import Outputable
 241 import Pretty
 242 import Util
 243 \end{code}
 244
 245 %************************************************************************
 246 %*                                                                      *
 247 \subsection[Unique-type]{@Unique@ type and operations}
 248 %*                                                                      *
 249 %************************************************************************
 250
 251 The @Chars@ are ``tag letters'' that identify the @UniqueSupply@.
 252 Fast comparison is everything on @Uniques@:
 253
 254 \begin{code}
 255 data Unique = MkUnique Int#
 256
 257 class Uniquable a where
 258     uniqueOf :: a -> Unique
 259 \end{code}
 260
 261 \begin{code}
 262 u2i :: Unique -> FAST_INT
 263 u2i (MkUnique i) = i
 264 \end{code}
 265
 266 Now come the functions which construct uniques from their pieces, and vice versa.
 267 The stuff about unique *supplies* is handled further down this module.
 268
 269 \begin{code}
 270 mkUnique        :: Char -> Int -> Unique        -- Builds a unique from pieces
 271 unpkUnique      :: Unique -> (Char, Int)        -- The reverse
 272
 273 mkUniqueGrimily :: Int# -> Unique               -- A trap-door for UniqSupply
 274
 275 incrUnique      :: Unique -> Unique
 276 \end{code}
 277
 278
 279 \begin{code}
 280 mkUniqueGrimily x = MkUnique x
 281
 282 incrUnique (MkUnique i) = MkUnique (i +# 1#)
 283
 284 -- pop the Char in the top 8 bits of the Unique(Supply)
 285
 286 -- No 64-bit bugs here, as long as we have at least 32 bits. --JSM
 287
 288 w2i x = word2Int# x
 289 i2w x = int2Word# x
 290 i2w_s x = (x::Int#)
 291
 292 mkUnique (C# c) (I# i)
 293   = MkUnique (w2i (((i2w (ord# c)) `shiftL#` (i2w_s 24#)) `or#` (i2w i)))
 294
 295 unpkUnique (MkUnique u)
 296   = let
 297         tag = C# (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#))))
 298         i   = I#  (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-}))
 299     in
 300     (tag, i)
 301   where
 302     shiftr x y = shiftRA# x y
 303 \end{code}
 304
 305 %************************************************************************
 306 %*                                                                      *
 307 \subsection[Unique-instances]{Instance declarations for @Unique@}
 308 %*                                                                      *
 309 %************************************************************************
 310
 311 And the whole point (besides uniqueness) is fast equality.  We don't
 312 use `deriving' because we want {\em precise} control of ordering
 313 (equality on @Uniques@ is v common).
 314
 315 \begin{code}
 316 eqUnique (MkUnique u1) (MkUnique u2) = u1 ==# u2
 317 ltUnique (MkUnique u1) (MkUnique u2) = u1 <#  u2
 318 leUnique (MkUnique u1) (MkUnique u2) = u1 <=# u2
 319
 320 cmpUnique (MkUnique u1) (MkUnique u2)
 321   = if u1 ==# u2 then EQ_ else if u1 <# u2 then LT_ else GT_
 322
 323 instance Eq Unique where
 324     a == b = eqUnique a b
 325     a /= b = not (eqUnique a b)
 326
 327 instance Ord Unique where
 328     a  < b = ltUnique a b
 329     a <= b = leUnique a b
 330     a  > b = not (leUnique a b)
 331     a >= b = not (ltUnique a b)
 332     _tagCmp a b = case cmpUnique a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
 333
 334 instance Ord3 Unique where
 335     cmp = cmpUnique
 336
 337 -----------------
 338 instance Uniquable Unique where
 339     uniqueOf u = u
 340 \end{code}
 341
 342 We do sometimes make strings with @Uniques@ in them:
 343 \begin{code}
 344 pprUnique, pprUnique10 :: Unique -> Doc
 345
 346 pprUnique uniq
 347   = case unpkUnique uniq of
 348       (tag, u) -> finish_ppr tag u (iToBase62 u)
 349
 350 pprUnique10 uniq        -- in base-10, dudes
 351   = case unpkUnique uniq of
 352       (tag, u) -> finish_ppr tag u (int u)
 353
 354 finish_ppr 't' u pp_u | u < 26
 355   =     -- Special case to make v common tyvars, t1, t2, ...
 356         -- come out as a, b, ... (shorter, easier to read)
 357     char (chr (ord 'a' + u))
 358 finish_ppr tag u pp_u = char tag <> pp_u
 359
 360 showUnique :: Unique -> String
 361 showUnique uniq = show (pprUnique uniq)
 362
 363 instance Outputable Unique where
 364     ppr sty u = pprUnique u
 365
 366 instance Text Unique where
 367     showsPrec p uniq rest = showUnique uniq
 368 \end{code}
 369
 370 %************************************************************************
 371 %*                                                                      *
 372 \subsection[Utils-base62]{Base-62 numbers}
 373 %*                                                                      *
 374 %************************************************************************
 375
 376 A character-stingy way to read/write numbers (notably Uniques).
 377 The ``62-its'' are \tr{[0-9a-zA-Z]}.  We don't handle negative Ints.
 378 Code stolen from Lennart.
 379 \begin{code}
 380 #if __GLASGOW_HASKELL__ == 201
 381 # define BYTE_ARRAY GHCbase.ByteArray
 382 # define RUN_ST     GHCbase.runST
 383 # define AND_THEN   >>=
 384 # define AND_THEN_  >>
 385 # define RETURN     return
 386 #elif __GLASGOW_HASKELL__ >= 202
 387 # define BYTE_ARRAY GlaExts.ByteArray
 388 # define RUN_ST     ST.runST
 389 # define AND_THEN   >>=
 390 # define AND_THEN_  >>
 391 # define RETURN     return
 392 #else
 393 # define BYTE_ARRAY _ByteArray
 394 # define RUN_ST     _runST
 395 # define AND_THEN   `thenStrictlyST`
 396 # define AND_THEN_  `seqStrictlyST`
 397 # define RETURN     returnStrictlyST
 398 #endif
 399
 400 iToBase62 :: Int -> Doc
 401
 402 iToBase62 n@(I# n#)
 403   = ASSERT(n >= 0)
 404     let
 405         bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes }
 406     in
 407     if n# <# 62# then
 408         case (indexCharArray# bytes n#) of { c ->
 409         char (C# c) }
 410     else
 411         case (quotRem n 62)             of { (q, I# r#) ->
 412         case (indexCharArray# bytes r#) of { c  ->
 413         (<>) (iToBase62 q) (char (C# c)) }}
 414
 415 -- keep this at top level! (bug on 94/10/24 WDP)
 416 chars62 :: BYTE_ARRAY Int
 417 chars62
 418   = RUN_ST (
 419         newCharArray (0, 61)    AND_THEN \ ch_array ->
 420         fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 421                                 AND_THEN_
 422         unsafeFreezeByteArray ch_array
 423     )
 424   where
 425     fill_in ch_array i lim str
 426       | i == lim
 427       = RETURN ()
 428       | otherwise
 429       = writeCharArray ch_array i (str !! i)    AND_THEN_
 430         fill_in ch_array (i+1) lim str
 431 \end{code}
 432
 433 %************************************************************************
 434 %*                                                                      *
 435 \subsection[Uniques-prelude]{@Uniques@ for wired-in Prelude things}
 436 %*                                                                      *
 437 %************************************************************************
 438
 439 Allocation of unique supply characters:
 440         v,t,u : for renumbering value-, type- and usage- vars.
 441         other a-z: lower case chars for unique supplies (see Main.lhs)
 442         B:   builtin
 443         C-E: pseudo uniques     (used in native-code generator)
 444         _:   unifiable tyvars   (above)
 445         1-8: prelude things below
 446
 447 \begin{code}
 448 mkAlphaTyVarUnique i            = mkUnique '1' i
 449
 450 mkPreludeClassUnique i          = mkUnique '2' i
 451 mkPreludeTyConUnique i          = mkUnique '3' i
 452 mkTupleTyConUnique a            = mkUnique '4' a
 453
 454 mkPreludeDataConUnique i        = mkUnique '5' i        -- must be alphabetic
 455 mkTupleDataConUnique a          = mkUnique '6' a        -- ditto (*may* be used in C labels)
 456
 457 mkPrimOpIdUnique op             = mkUnique '7' op
 458 mkPreludeMiscIdUnique i         = mkUnique '8' i
 459
 460 -- The "tyvar uniques" print specially nicely: a, b, c, etc.
 461 -- See pprUnique for details
 462
 463 initTyVarUnique :: Unique
 464 initTyVarUnique = mkUnique 't' 0
 465
 466 mkTyVarUnique :: Int -> Unique
 467 mkTyVarUnique n = mkUnique 't' n
 468
 469 initTidyUniques :: (Unique, Unique)     -- Global and local
 470 initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
 471
 472 mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
 473  mkBuiltinUnique :: Int -> Unique
 474
 475 mkBuiltinUnique i = mkUnique 'B' i
 476 mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs
 477 mkPseudoUnique2 i = mkUnique 'D' i -- ditto
 478 mkPseudoUnique3 i = mkUnique 'E' i -- ditto
 479
 480 getBuiltinUniques :: Int -> [Unique]
 481 getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
 482 \end{code}
 483
 484 %************************************************************************
 485 %*                                                                      *
 486 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 487 %*                                                                      *
 488 %************************************************************************
 489
 490 \begin{code}
 491 boundedClassKey         = mkPreludeClassUnique 1
 492 enumClassKey            = mkPreludeClassUnique 2
 493 eqClassKey              = mkPreludeClassUnique 3
 494 evalClassKey            = mkPreludeClassUnique 4
 495 floatingClassKey        = mkPreludeClassUnique 5
 496 fractionalClassKey      = mkPreludeClassUnique 6
 497 integralClassKey        = mkPreludeClassUnique 7
 498 monadClassKey           = mkPreludeClassUnique 8
 499 monadZeroClassKey       = mkPreludeClassUnique 9
 500 monadPlusClassKey       = mkPreludeClassUnique 10
 501 functorClassKey         = mkPreludeClassUnique 11
 502 numClassKey             = mkPreludeClassUnique 12
 503 ordClassKey             = mkPreludeClassUnique 13
 504 readClassKey            = mkPreludeClassUnique 14
 505 realClassKey            = mkPreludeClassUnique 15
 506 realFloatClassKey       = mkPreludeClassUnique 16
 507 realFracClassKey        = mkPreludeClassUnique 17
 508 showClassKey            = mkPreludeClassUnique 18
 509
 510 cCallableClassKey       = mkPreludeClassUnique 19
 511 cReturnableClassKey     = mkPreludeClassUnique 20
 512
 513 ixClassKey              = mkPreludeClassUnique 21
 514 allClassKey             = mkPreludeClassUnique 22       -- Pseudo class used for universal quantification
 515 \end{code}
 516
 517 %************************************************************************
 518 %*                                                                      *
 519 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 520 %*                                                                      *
 521 %************************************************************************
 522
 523 \begin{code}
 524 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 525 addrTyConKey                            = mkPreludeTyConUnique  2
 526 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 527 boolTyConKey                            = mkPreludeTyConUnique  4
 528 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 529 charPrimTyConKey                        = mkPreludeTyConUnique  7
 530 charTyConKey                            = mkPreludeTyConUnique  8
 531 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 532 doubleTyConKey                          = mkPreludeTyConUnique 10
 533 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 534 floatTyConKey                           = mkPreludeTyConUnique 12
 535 funTyConKey                             = mkPreludeTyConUnique 13
 536 iOTyConKey                              = mkPreludeTyConUnique 14
 537 intPrimTyConKey                         = mkPreludeTyConUnique 15
 538 intTyConKey                             = mkPreludeTyConUnique 16
 539 integerTyConKey                         = mkPreludeTyConUnique 17
 540 liftTyConKey                            = mkPreludeTyConUnique 18
 541 listTyConKey                            = mkPreludeTyConUnique 19
 542 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 20
 543 foreignObjTyConKey                      = mkPreludeTyConUnique 21
 544 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 22
 545 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 23
 546 orderingTyConKey                        = mkPreludeTyConUnique 24
 547 synchVarPrimTyConKey                    = mkPreludeTyConUnique 25
 548 ratioTyConKey                           = mkPreludeTyConUnique 26
 549 rationalTyConKey                        = mkPreludeTyConUnique 27
 550 realWorldTyConKey                       = mkPreludeTyConUnique 28
 551 return2GMPsTyConKey                     = mkPreludeTyConUnique 29
 552 returnIntAndGMPTyConKey                 = mkPreludeTyConUnique 30
 553 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 31
 554 stablePtrTyConKey                       = mkPreludeTyConUnique 32
 555 stateAndAddrPrimTyConKey                = mkPreludeTyConUnique 33
 556 stateAndArrayPrimTyConKey               = mkPreludeTyConUnique 34
 557 stateAndByteArrayPrimTyConKey           = mkPreludeTyConUnique 35
 558 stateAndCharPrimTyConKey                = mkPreludeTyConUnique 36
 559 stateAndDoublePrimTyConKey              = mkPreludeTyConUnique 37
 560 stateAndFloatPrimTyConKey               = mkPreludeTyConUnique 38
 561 stateAndIntPrimTyConKey                 = mkPreludeTyConUnique 39
 562 stateAndForeignObjPrimTyConKey          = mkPreludeTyConUnique 40
 563 stateAndMutableArrayPrimTyConKey        = mkPreludeTyConUnique 41
 564 stateAndMutableByteArrayPrimTyConKey    = mkPreludeTyConUnique 42
 565 stateAndSynchVarPrimTyConKey            = mkPreludeTyConUnique 43
 566 stateAndPtrPrimTyConKey                 = mkPreludeTyConUnique 44
 567 stateAndStablePtrPrimTyConKey           = mkPreludeTyConUnique 45
 568 stateAndWordPrimTyConKey                = mkPreludeTyConUnique 46
 569 statePrimTyConKey                       = mkPreludeTyConUnique 47
 570 stateTyConKey                           = mkPreludeTyConUnique 48
 571 mutableByteArrayTyConKey                = mkPreludeTyConUnique 49
 572 stTyConKey                              = mkPreludeTyConUnique 50
 573 primIoTyConKey                          = mkPreludeTyConUnique 51
 574 byteArrayTyConKey                       = mkPreludeTyConUnique 52
 575 wordPrimTyConKey                        = mkPreludeTyConUnique 53
 576 wordTyConKey                            = mkPreludeTyConUnique 54
 577 voidTyConKey                            = mkPreludeTyConUnique 55
 578 stRetTyConKey                           = mkPreludeTyConUnique 56
 579 \end{code}
 580
 581 %************************************************************************
 582 %*                                                                      *
 583 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 584 %*                                                                      *
 585 %************************************************************************
 586
 587 \begin{code}
 588 addrDataConKey                          = mkPreludeDataConUnique  1
 589 buildDataConKey                         = mkPreludeDataConUnique  2
 590 charDataConKey                          = mkPreludeDataConUnique  4
 591 consDataConKey                          = mkPreludeDataConUnique  5
 592 doubleDataConKey                        = mkPreludeDataConUnique  6
 593 eqDataConKey                            = mkPreludeDataConUnique  7
 594 falseDataConKey                         = mkPreludeDataConUnique  8
 595 floatDataConKey                         = mkPreludeDataConUnique  9
 596 gtDataConKey                            = mkPreludeDataConUnique 10
 597 intDataConKey                           = mkPreludeDataConUnique 11
 598 integerDataConKey                       = mkPreludeDataConUnique 12
 599 liftDataConKey                          = mkPreludeDataConUnique 13
 600 ltDataConKey                            = mkPreludeDataConUnique 14
 601 foreignObjDataConKey                    = mkPreludeDataConUnique 15
 602 nilDataConKey                           = mkPreludeDataConUnique 18
 603 ratioDataConKey                         = mkPreludeDataConUnique 21
 604 return2GMPsDataConKey                   = mkPreludeDataConUnique 22
 605 returnIntAndGMPDataConKey               = mkPreludeDataConUnique 23
 606 stablePtrDataConKey                     = mkPreludeDataConUnique 24
 607 stateAndAddrPrimDataConKey              = mkPreludeDataConUnique 25
 608 stateAndArrayPrimDataConKey             = mkPreludeDataConUnique 26
 609 stateAndByteArrayPrimDataConKey         = mkPreludeDataConUnique 27
 610 stateAndCharPrimDataConKey              = mkPreludeDataConUnique 28
 611 stateAndDoublePrimDataConKey            = mkPreludeDataConUnique 29
 612 stateAndFloatPrimDataConKey             = mkPreludeDataConUnique 30
 613 stateAndIntPrimDataConKey               = mkPreludeDataConUnique 31
 614 stateAndForeignObjPrimDataConKey        = mkPreludeDataConUnique 32
 615 stateAndMutableArrayPrimDataConKey      = mkPreludeDataConUnique 33
 616 stateAndMutableByteArrayPrimDataConKey  = mkPreludeDataConUnique 34
 617 stateAndSynchVarPrimDataConKey          = mkPreludeDataConUnique 35
 618 stateAndPtrPrimDataConKey               = mkPreludeDataConUnique 36
 619 stateAndStablePtrPrimDataConKey         = mkPreludeDataConUnique 37
 620 stateAndWordPrimDataConKey              = mkPreludeDataConUnique 38
 621 stateDataConKey                         = mkPreludeDataConUnique 39
 622 trueDataConKey                          = mkPreludeDataConUnique 40
 623 wordDataConKey                          = mkPreludeDataConUnique 41
 624 stDataConKey                            = mkPreludeDataConUnique 42
 625 stRetDataConKey                         = mkPreludeDataConUnique 43
 626 \end{code}
 627
 628 %************************************************************************
 629 %*                                                                      *
 630 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 631 %*                                                                      *
 632 %************************************************************************
 633
 634 \begin{code}
 635 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 636 andandIdKey                   = mkPreludeMiscIdUnique  2
 637 appendIdKey                   = mkPreludeMiscIdUnique  3
 638 augmentIdKey                  = mkPreludeMiscIdUnique  4
 639 buildIdKey                    = mkPreludeMiscIdUnique  5
 640 composeIdKey                  = mkPreludeMiscIdUnique  6
 641 errorIdKey                    = mkPreludeMiscIdUnique  7
 642 foldlIdKey                    = mkPreludeMiscIdUnique  8
 643 foldrIdKey                    = mkPreludeMiscIdUnique  9
 644 forkIdKey                     = mkPreludeMiscIdUnique 10
 645 int2IntegerIdKey              = mkPreludeMiscIdUnique 11
 646 integerMinusOneIdKey          = mkPreludeMiscIdUnique 12
 647 integerPlusOneIdKey           = mkPreludeMiscIdUnique 13
 648 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 14
 649 integerZeroIdKey              = mkPreludeMiscIdUnique 15
 650 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 651 lexIdKey                      = mkPreludeMiscIdUnique 17
 652 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 20
 653 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
 654 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 22
 655 notIdKey                      = mkPreludeMiscIdUnique 23
 656 packCStringIdKey              = mkPreludeMiscIdUnique 24
 657 parErrorIdKey                 = mkPreludeMiscIdUnique 25
 658 parIdKey                      = mkPreludeMiscIdUnique 26
 659 patErrorIdKey                 = mkPreludeMiscIdUnique 27
 660 readParenIdKey                = mkPreludeMiscIdUnique 28
 661 realWorldPrimIdKey            = mkPreludeMiscIdUnique 29
 662 recConErrorIdKey              = mkPreludeMiscIdUnique 30
 663 recUpdErrorIdKey              = mkPreludeMiscIdUnique 31
 664 runSTIdKey                    = mkPreludeMiscIdUnique 32
 665 seqIdKey                      = mkPreludeMiscIdUnique 33
 666 showParenIdKey                = mkPreludeMiscIdUnique 34
 667 showSpaceIdKey                = mkPreludeMiscIdUnique 35
 668 showStringIdKey               = mkPreludeMiscIdUnique 36
 669 traceIdKey                    = mkPreludeMiscIdUnique 37
 670 unpackCString2IdKey           = mkPreludeMiscIdUnique 38
 671 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 39
 672 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 40
 673 unpackCStringIdKey            = mkPreludeMiscIdUnique 41
 674 voidIdKey                     = mkPreludeMiscIdUnique 42
 675 ushowListIdKey                = mkPreludeMiscIdUnique 43
 676 ureadListIdKey                = mkPreludeMiscIdUnique 44
 677
 678 copyableIdKey           = mkPreludeMiscIdUnique 45
 679 noFollowIdKey           = mkPreludeMiscIdUnique 46
 680 parAtAbsIdKey           = mkPreludeMiscIdUnique 47
 681 parAtForNowIdKey        = mkPreludeMiscIdUnique 48
 682 parAtIdKey              = mkPreludeMiscIdUnique 49
 683 parAtRelIdKey           = mkPreludeMiscIdUnique 50
 684 parGlobalIdKey          = mkPreludeMiscIdUnique 51
 685 parLocalIdKey           = mkPreludeMiscIdUnique 52
 686 \end{code}
 687
 688 Certain class operations from Prelude classes.  They get
 689 their own uniques so we can look them up easily when we want
 690 to conjure them up during type checking.
 691 \begin{code}
 692 fromIntClassOpKey       = mkPreludeMiscIdUnique 53
 693 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 54
 694 minusClassOpKey         = mkPreludeMiscIdUnique 69
 695 fromRationalClassOpKey  = mkPreludeMiscIdUnique 55
 696 enumFromClassOpKey      = mkPreludeMiscIdUnique 56
 697 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 57
 698 enumFromToClassOpKey    = mkPreludeMiscIdUnique 58
 699 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59
 700 eqClassOpKey            = mkPreludeMiscIdUnique 60
 701 geClassOpKey            = mkPreludeMiscIdUnique 61
 702 zeroClassOpKey          = mkPreludeMiscIdUnique 62
 703 thenMClassOpKey         = mkPreludeMiscIdUnique 63 -- (>>=)
 704 unboundKey              = mkPreludeMiscIdUnique 64      -- Just a place holder for unbound
 705                                                         -- variables produced by the renamer
 706 fromEnumClassOpKey      = mkPreludeMiscIdUnique 65
 707
 708 mainKey                 = mkPreludeMiscIdUnique 66
 709 mainPrimIoKey           = mkPreludeMiscIdUnique 67
 710 returnMClassOpKey       = mkPreludeMiscIdUnique 68
 711 -- Used for minusClassOp                        69
 712 otherwiseIdKey          = mkPreludeMiscIdUnique 70
 713 toEnumClassOpKey        = mkPreludeMiscIdUnique 71
 714 \end{code}