X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FbasicTypes%2FUnique.lhs;h=1c0dda9bd45099260713b636d293e2424890c1f0;hb=438596897ebbe25a07e1c82085cfbc5bdb00f09e;hp=3dbdbcd8873c38c0ede9f8e1edc82e19881693c3;hpb=2494407a750053daa61718fac371487d04818e57;p=ghc-hetmet.git diff --git a/ghc/compiler/basicTypes/Unique.lhs b/ghc/compiler/basicTypes/Unique.lhs index 3dbdbcd..1c0dda9 100644 --- a/ghc/compiler/basicTypes/Unique.lhs +++ b/ghc/compiler/basicTypes/Unique.lhs @@ -1,7 +1,6 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % -\section[Unique]{The @Unique@ data type} @Uniques@ are used to distinguish entities in the compiler (@Ids@, @Classes@, etc.) from each other. Thus, @Uniques@ are the basic @@ -16,28 +15,28 @@ Some of the other hair in this code is to be able to use a Haskell). \begin{code} -#include "HsVersions.h" - --- UniqSupply - module Unique ( - Unique, + Unique, Uniquable(..), u2i, -- hack: used in UniqFM - pprUnique, pprUnique10, showUnique, + pprUnique, pprUnique10, mkUnique, -- Used in UniqSupply mkUniqueGrimily, -- Used in UniqSupply only! + getKey, -- Used in Var only! incrUnique, -- Used for renumbering - initRenumberingUniques, + initTyVarUnique, + initTidyUniques, -- now all the built-in Uniques (and functions to make them) -- [the Oh-So-Wonderful Haskell module system wins again...] mkAlphaTyVarUnique, mkPrimOpIdUnique, mkTupleDataConUnique, + mkUbxTupleDataConUnique, mkTupleTyConUnique, + mkUbxTupleTyConUnique, getBuiltinUniques, mkBuiltinUnique, mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3, @@ -46,13 +45,13 @@ module Unique ( addrDataConKey, addrPrimTyConKey, addrTyConKey, - andandIdKey, appendIdKey, arrayPrimTyConKey, + assertIdKey, augmentIdKey, boolTyConKey, boundedClassKey, - buildDataConKey, + boxedKindConKey, buildIdKey, byteArrayPrimTyConKey, cCallableClassKey, @@ -60,7 +59,7 @@ module Unique ( charDataConKey, charPrimTyConKey, charTyConKey, - composeIdKey, + concatIdKey, consDataConKey, doubleDataConKey, doublePrimTyConKey, @@ -72,10 +71,9 @@ module Unique ( enumFromToClassOpKey, eqClassKey, eqClassOpKey, - eqDataConKey, errorIdKey, - evalClassKey, falseDataConKey, + filterIdKey, floatDataConKey, floatPrimTyConKey, floatTyConKey, @@ -85,7 +83,7 @@ module Unique ( foreignObjDataConKey, foreignObjPrimTyConKey, foreignObjTyConKey, - forkIdKey, + weakPrimTyConKey, fractionalClassKey, fromEnumClassOpKey, fromIntClassOpKey, @@ -94,38 +92,44 @@ module Unique ( funTyConKey, functorClassKey, geClassOpKey, - gtDataConKey, - iOTyConKey, intDataConKey, intPrimTyConKey, intTyConKey, + int8TyConKey, + int8DataConKey, + int16TyConKey, + int16DataConKey, + int32TyConKey, + int32DataConKey, + int64DataConKey, + int64PrimTyConKey, + int64TyConKey, integerDataConKey, integerMinusOneIdKey, integerPlusOneIdKey, integerPlusTwoIdKey, + int2IntegerIdKey, + addr2IntegerIdKey, integerTyConKey, integerZeroIdKey, integralClassKey, irrefutPatErrorIdKey, ixClassKey, - lexIdKey, - liftDataConKey, - liftTyConKey, listTyConKey, - ltDataConKey, - mainKey, mainPrimIoKey, + mainKey, + mapIdKey, minusClassOpKey, monadClassKey, monadPlusClassKey, monadZeroClassKey, mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, + mutVarPrimTyConKey, nilDataConKey, - noDefaultMethodErrorIdKey, + noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey, - nonExplicitMethodErrorIdKey, - notIdKey, numClassKey, + openKindConKey, ordClassKey, orderingTyConKey, otherwiseIdKey, @@ -133,99 +137,75 @@ module Unique ( parErrorIdKey, parIdKey, patErrorIdKey, - primIoTyConKey, ratioDataConKey, ratioTyConKey, rationalTyConKey, readClassKey, - readParenIdKey, realClassKey, realFloatClassKey, realFracClassKey, realWorldPrimIdKey, realWorldTyConKey, recConErrorIdKey, + recSelErrIdKey, recUpdErrorIdKey, - return2GMPsDataConKey, - return2GMPsTyConKey, - returnIntAndGMPDataConKey, - returnIntAndGMPTyConKey, returnMClassOpKey, - runSTIdKey, - seqIdKey, showClassKey, - showParenIdKey, - showSpaceIdKey, - showStringIdKey, - stTyConKey, - stDataConKey, + ioTyConKey, + ioDataConKey, stablePtrDataConKey, stablePtrPrimTyConKey, stablePtrTyConKey, - stateAndAddrPrimDataConKey, - stateAndAddrPrimTyConKey, - stateAndArrayPrimDataConKey, - stateAndArrayPrimTyConKey, - stateAndByteArrayPrimDataConKey, - stateAndByteArrayPrimTyConKey, - stateAndCharPrimDataConKey, - stateAndCharPrimTyConKey, - stateAndDoublePrimDataConKey, - stateAndDoublePrimTyConKey, - stateAndFloatPrimDataConKey, - stateAndFloatPrimTyConKey, - stateAndForeignObjPrimDataConKey, - stateAndForeignObjPrimTyConKey, - stateAndIntPrimDataConKey, - stateAndIntPrimTyConKey, - stateAndMutableArrayPrimDataConKey, - stateAndMutableArrayPrimTyConKey, - stateAndMutableByteArrayPrimDataConKey, - stateAndMutableByteArrayPrimTyConKey, - stateAndPtrPrimDataConKey, - stateAndPtrPrimTyConKey, - stateAndStablePtrPrimDataConKey, - stateAndStablePtrPrimTyConKey, - stateAndSynchVarPrimDataConKey, - stateAndSynchVarPrimTyConKey, - stateAndWordPrimDataConKey, - stateAndWordPrimTyConKey, stateDataConKey, - statePrimTyConKey, stateTyConKey, - synchVarPrimTyConKey, + + statePrimTyConKey, + superKindConKey, + mVarPrimTyConKey, thenMClassOpKey, + threadIdPrimTyConKey, toEnumClassOpKey, traceIdKey, trueDataConKey, + unboxedKindConKey, unpackCString2IdKey, unpackCStringAppendIdKey, unpackCStringFoldrIdKey, unpackCStringIdKey, - ureadListIdKey, + unsafeCoerceIdKey, ushowListIdKey, voidIdKey, voidTyConKey, wordDataConKey, wordPrimTyConKey, wordTyConKey, - zeroClassOpKey - , copyableIdKey - , noFollowIdKey - , parAtAbsIdKey - , parAtForNowIdKey - , parAtIdKey - , parAtRelIdKey - , parGlobalIdKey - , parLocalIdKey - , unboundKey + word8TyConKey, + word8DataConKey, + word16TyConKey, + word16DataConKey, + word32TyConKey, + word32DataConKey, + word64DataConKey, + word64PrimTyConKey, + word64TyConKey, + zeroClassOpKey, + zipIdKey, + bindIOIdKey, + deRefStablePtrIdKey, + makeStablePtrIdKey, + unboundKey, + byteArrayTyConKey, + mutableByteArrayTyConKey ) where -import PreludeGlaST +#include "HsVersions.h" -IMP_Ubiq(){-uitous-} +import FastString ( uniqueOfFS ) +import GlaExts +import ST +import PrelBase ( Char(..), chr, ord ) -import Pretty +import Outputable import Util \end{code} @@ -239,9 +219,11 @@ The @Chars@ are ``tag letters'' that identify the @UniqueSupply@. Fast comparison is everything on @Uniques@: \begin{code} -u2i :: Unique -> FAST_INT - data Unique = MkUnique Int# +\end{code} + +\begin{code} +u2i :: Unique -> FAST_INT u2i (MkUnique i) = i \end{code} @@ -254,6 +236,8 @@ unpkUnique :: Unique -> (Char, Int) -- The reverse mkUniqueGrimily :: Int# -> Unique -- A trap-door for UniqSupply +getKey :: Unique -> Int# -- for Var + incrUnique :: Unique -> Unique \end{code} @@ -261,6 +245,9 @@ incrUnique :: Unique -> Unique \begin{code} mkUniqueGrimily x = MkUnique x +{-# INLINE getKey #-} +getKey (MkUnique x) = x + incrUnique (MkUnique i) = MkUnique (i +# 1#) -- pop the Char in the top 8 bits of the Unique(Supply) @@ -281,9 +268,29 @@ unpkUnique (MkUnique u) in (tag, i) where - shiftr x y = shiftRA# x y + shiftr x y = shiftRL# x y \end{code} + + +%************************************************************************ +%* * +\subsection[Uniquable-class]{The @Uniquable@ class} +%* * +%************************************************************************ + +\begin{code} +class Uniquable a where + getUnique :: a -> Unique + +instance Uniquable FastString where + getUnique fs = mkUniqueGrimily (uniqueOfFS fs) + +instance Uniquable Int where + getUnique (I# i#) = mkUniqueGrimily i# +\end{code} + + %************************************************************************ %* * \subsection[Unique-instances]{Instance declarations for @Unique@} @@ -300,7 +307,7 @@ ltUnique (MkUnique u1) (MkUnique u2) = u1 <# u2 leUnique (MkUnique u1) (MkUnique u2) = u1 <=# u2 cmpUnique (MkUnique u1) (MkUnique u2) - = if u1 ==# u2 then EQ_ else if u1 <# u2 then LT_ else GT_ + = if u1 ==# u2 then EQ else if u1 <# u2 then LT else GT instance Eq Unique where a == b = eqUnique a b @@ -311,19 +318,16 @@ instance Ord Unique where a <= b = leUnique a b a > b = not (leUnique a b) a >= b = not (ltUnique a b) - _tagCmp a b = case cmpUnique a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT } - -instance Ord3 Unique where - cmp = cmpUnique + compare a b = cmpUnique a b ----------------- instance Uniquable Unique where - uniqueOf u = u + getUnique u = u \end{code} We do sometimes make strings with @Uniques@ in them: \begin{code} -pprUnique, pprUnique10 :: Unique -> Pretty +pprUnique, pprUnique10 :: Unique -> SDoc pprUnique uniq = case unpkUnique uniq of @@ -331,30 +335,19 @@ pprUnique uniq pprUnique10 uniq -- in base-10, dudes = case unpkUnique uniq of - (tag, u) -> finish_ppr tag u (ppInt u) - -finish_ppr tag u pp_u - = if tag /= 't' -- this is just to make v common tyvars, t1, t2, ... - -- come out as a, b, ... (shorter, easier to read) - then pp_all - else case u of - 1 -> ppChar 'a' - 2 -> ppChar 'b' - 3 -> ppChar 'c' - 4 -> ppChar 'd' - 5 -> ppChar 'e' - _ -> pp_all - where - pp_all = ppBeside (ppChar tag) pp_u + (tag, u) -> finish_ppr tag u (int u) -showUnique :: Unique -> FAST_STRING -showUnique uniq = _PK_ (ppShow 80 (pprUnique uniq)) +finish_ppr 't' u pp_u | u < 26 + = -- Special case to make v common tyvars, t1, t2, ... + -- come out as a, b, ... (shorter, easier to read) + char (chr (ord 'a' + u)) +finish_ppr tag u pp_u = char tag <> pp_u instance Outputable Unique where - ppr sty u = pprUnique u + ppr u = pprUnique u -instance Text Unique where - showsPrec p uniq rest = _UNPK_ (showUnique uniq) +instance Show Unique where + showsPrec p uniq = showsPrecSDoc p (pprUnique uniq) \end{code} %************************************************************************ @@ -367,21 +360,13 @@ A character-stingy way to read/write numbers (notably Uniques). The ``62-its'' are \tr{[0-9a-zA-Z]}. We don't handle negative Ints. Code stolen from Lennart. \begin{code} -#if __GLASGOW_HASKELL__ >= 200 -# define BYTE_ARRAY GHCbase.ByteArray -# define RUN_ST GHCbase.runST +# define BYTE_ARRAY GlaExts.ByteArray +# define RUN_ST ST.runST # define AND_THEN >>= # define AND_THEN_ >> # define RETURN return -#else -# define BYTE_ARRAY _ByteArray -# define RUN_ST _runST -# define AND_THEN `thenStrictlyST` -# define AND_THEN_ `seqStrictlyST` -# define RETURN returnStrictlyST -#endif -iToBase62 :: Int -> Pretty +iToBase62 :: Int -> SDoc iToBase62 n@(I# n#) = ASSERT(n >= 0) @@ -390,11 +375,11 @@ iToBase62 n@(I# n#) in if n# <# 62# then case (indexCharArray# bytes n#) of { c -> - ppChar (C# c) } + char (C# c) } else case (quotRem n 62) of { (q, I# r#) -> case (indexCharArray# bytes r#) of { c -> - ppBeside (iToBase62 q) (ppChar (C# c)) }} + (<>) (iToBase62 q) (char (C# c)) }} -- keep this at top level! (bug on 94/10/24 WDP) chars62 :: BYTE_ARRAY Int @@ -426,28 +411,37 @@ Allocation of unique supply characters: B: builtin C-E: pseudo uniques (used in native-code generator) _: unifiable tyvars (above) - 1-8: prelude things below + 0-9: prelude things below \begin{code} -mkAlphaTyVarUnique i = mkUnique '1' i +mkAlphaTyVarUnique i = mkUnique '1' i mkPreludeClassUnique i = mkUnique '2' i mkPreludeTyConUnique i = mkUnique '3' i mkTupleTyConUnique a = mkUnique '4' a +mkUbxTupleTyConUnique a = mkUnique '5' a + +mkPreludeDataConUnique i = mkUnique '6' i -- must be alphabetic +mkTupleDataConUnique a = mkUnique '7' a -- ditto (*may* be used in C labels) +mkUbxTupleDataConUnique a = mkUnique '8' a -mkPreludeDataConUnique i = mkUnique '5' i -- must be alphabetic -mkTupleDataConUnique a = mkUnique '6' a -- ditto (*may* be used in C labels) +mkPrimOpIdUnique op = mkUnique '9' op +mkPreludeMiscIdUnique i = mkUnique '0' i -mkPrimOpIdUnique op = mkUnique '7' op -mkPreludeMiscIdUnique i = mkUnique '8' i +-- The "tyvar uniques" print specially nicely: a, b, c, etc. +-- See pprUnique for details -initRenumberingUniques = (mkUnique 'v' 1, mkUnique 't' 1, mkUnique 'u' 1) +initTyVarUnique :: Unique +initTyVarUnique = mkUnique 't' 0 + +initTidyUniques :: (Unique, Unique) -- Global and local +initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0) mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3, mkBuiltinUnique :: Int -> Unique mkBuiltinUnique i = mkUnique 'B' i -mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs +mkPseudoUnique1 i = mkUnique 'C' i -- used for getUnique on Regs mkPseudoUnique2 i = mkUnique 'D' i -- ditto mkPseudoUnique3 i = mkUnique 'E' i -- ditto @@ -465,7 +459,6 @@ getBuiltinUniques n = map (mkUnique 'B') [1 .. n] boundedClassKey = mkPreludeClassUnique 1 enumClassKey = mkPreludeClassUnique 2 eqClassKey = mkPreludeClassUnique 3 -evalClassKey = mkPreludeClassUnique 4 floatingClassKey = mkPreludeClassUnique 5 fractionalClassKey = mkPreludeClassUnique 6 integralClassKey = mkPreludeClassUnique 7 @@ -506,48 +499,47 @@ doubleTyConKey = mkPreludeTyConUnique 10 floatPrimTyConKey = mkPreludeTyConUnique 11 floatTyConKey = mkPreludeTyConUnique 12 funTyConKey = mkPreludeTyConUnique 13 -iOTyConKey = mkPreludeTyConUnique 14 -intPrimTyConKey = mkPreludeTyConUnique 15 -intTyConKey = mkPreludeTyConUnique 16 -integerTyConKey = mkPreludeTyConUnique 17 -liftTyConKey = mkPreludeTyConUnique 18 -listTyConKey = mkPreludeTyConUnique 19 -foreignObjPrimTyConKey = mkPreludeTyConUnique 20 -foreignObjTyConKey = mkPreludeTyConUnique 21 -mutableArrayPrimTyConKey = mkPreludeTyConUnique 22 -mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 23 -orderingTyConKey = mkPreludeTyConUnique 24 -synchVarPrimTyConKey = mkPreludeTyConUnique 25 -ratioTyConKey = mkPreludeTyConUnique 26 -rationalTyConKey = mkPreludeTyConUnique 27 -realWorldTyConKey = mkPreludeTyConUnique 28 -return2GMPsTyConKey = mkPreludeTyConUnique 29 -returnIntAndGMPTyConKey = mkPreludeTyConUnique 30 -stablePtrPrimTyConKey = mkPreludeTyConUnique 31 -stablePtrTyConKey = mkPreludeTyConUnique 32 -stateAndAddrPrimTyConKey = mkPreludeTyConUnique 33 -stateAndArrayPrimTyConKey = mkPreludeTyConUnique 34 -stateAndByteArrayPrimTyConKey = mkPreludeTyConUnique 35 -stateAndCharPrimTyConKey = mkPreludeTyConUnique 36 -stateAndDoublePrimTyConKey = mkPreludeTyConUnique 37 -stateAndFloatPrimTyConKey = mkPreludeTyConUnique 38 -stateAndIntPrimTyConKey = mkPreludeTyConUnique 39 -stateAndForeignObjPrimTyConKey = mkPreludeTyConUnique 40 -stateAndMutableArrayPrimTyConKey = mkPreludeTyConUnique 41 -stateAndMutableByteArrayPrimTyConKey = mkPreludeTyConUnique 42 -stateAndSynchVarPrimTyConKey = mkPreludeTyConUnique 43 -stateAndPtrPrimTyConKey = mkPreludeTyConUnique 44 -stateAndStablePtrPrimTyConKey = mkPreludeTyConUnique 45 -stateAndWordPrimTyConKey = mkPreludeTyConUnique 46 -statePrimTyConKey = mkPreludeTyConUnique 47 -stateTyConKey = mkPreludeTyConUnique 48 - -- 49 is spare -stTyConKey = mkPreludeTyConUnique 50 -primIoTyConKey = mkPreludeTyConUnique 51 - -- 52 is spare -wordPrimTyConKey = mkPreludeTyConUnique 53 -wordTyConKey = mkPreludeTyConUnique 54 -voidTyConKey = mkPreludeTyConUnique 55 +intPrimTyConKey = mkPreludeTyConUnique 14 +intTyConKey = mkPreludeTyConUnique 15 +int8TyConKey = mkPreludeTyConUnique 16 +int16TyConKey = mkPreludeTyConUnique 17 +int32TyConKey = mkPreludeTyConUnique 18 +int64PrimTyConKey = mkPreludeTyConUnique 19 +int64TyConKey = mkPreludeTyConUnique 20 +integerTyConKey = mkPreludeTyConUnique 21 +listTyConKey = mkPreludeTyConUnique 22 +foreignObjPrimTyConKey = mkPreludeTyConUnique 23 +foreignObjTyConKey = mkPreludeTyConUnique 24 +weakPrimTyConKey = mkPreludeTyConUnique 25 +mutableArrayPrimTyConKey = mkPreludeTyConUnique 26 +mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 27 +orderingTyConKey = mkPreludeTyConUnique 28 +mVarPrimTyConKey = mkPreludeTyConUnique 29 +ratioTyConKey = mkPreludeTyConUnique 30 +rationalTyConKey = mkPreludeTyConUnique 31 +realWorldTyConKey = mkPreludeTyConUnique 32 +stablePtrPrimTyConKey = mkPreludeTyConUnique 33 +stablePtrTyConKey = mkPreludeTyConUnique 34 +stateTyConKey = mkPreludeTyConUnique 50 +statePrimTyConKey = mkPreludeTyConUnique 51 +mutableByteArrayTyConKey = mkPreludeTyConUnique 52 +mutVarPrimTyConKey = mkPreludeTyConUnique 53 +ioTyConKey = mkPreludeTyConUnique 55 +byteArrayTyConKey = mkPreludeTyConUnique 56 +wordPrimTyConKey = mkPreludeTyConUnique 57 +wordTyConKey = mkPreludeTyConUnique 58 +word8TyConKey = mkPreludeTyConUnique 59 +word16TyConKey = mkPreludeTyConUnique 60 +word32TyConKey = mkPreludeTyConUnique 61 +word64PrimTyConKey = mkPreludeTyConUnique 62 +word64TyConKey = mkPreludeTyConUnique 63 +voidTyConKey = mkPreludeTyConUnique 64 +boxedKindConKey = mkPreludeTyConUnique 65 +unboxedKindConKey = mkPreludeTyConUnique 66 +openKindConKey = mkPreludeTyConUnique 67 +superKindConKey = mkPreludeTyConUnique 68 +threadIdPrimTyConKey = mkPreludeTyConUnique 69 + \end{code} %************************************************************************ @@ -558,42 +550,30 @@ voidTyConKey = mkPreludeTyConUnique 55 \begin{code} addrDataConKey = mkPreludeDataConUnique 1 -buildDataConKey = mkPreludeDataConUnique 2 -charDataConKey = mkPreludeDataConUnique 4 -consDataConKey = mkPreludeDataConUnique 5 -doubleDataConKey = mkPreludeDataConUnique 6 -eqDataConKey = mkPreludeDataConUnique 7 -falseDataConKey = mkPreludeDataConUnique 8 -floatDataConKey = mkPreludeDataConUnique 9 -gtDataConKey = mkPreludeDataConUnique 10 -intDataConKey = mkPreludeDataConUnique 11 +charDataConKey = mkPreludeDataConUnique 2 +consDataConKey = mkPreludeDataConUnique 3 +doubleDataConKey = mkPreludeDataConUnique 4 +falseDataConKey = mkPreludeDataConUnique 5 +floatDataConKey = mkPreludeDataConUnique 6 +intDataConKey = mkPreludeDataConUnique 7 +int8DataConKey = mkPreludeDataConUnique 8 +int16DataConKey = mkPreludeDataConUnique 9 +int32DataConKey = mkPreludeDataConUnique 10 +int64DataConKey = mkPreludeDataConUnique 11 integerDataConKey = mkPreludeDataConUnique 12 -liftDataConKey = mkPreludeDataConUnique 13 -ltDataConKey = mkPreludeDataConUnique 14 -foreignObjDataConKey = mkPreludeDataConUnique 15 -nilDataConKey = mkPreludeDataConUnique 18 -ratioDataConKey = mkPreludeDataConUnique 21 -return2GMPsDataConKey = mkPreludeDataConUnique 22 -returnIntAndGMPDataConKey = mkPreludeDataConUnique 23 -stablePtrDataConKey = mkPreludeDataConUnique 24 -stateAndAddrPrimDataConKey = mkPreludeDataConUnique 25 -stateAndArrayPrimDataConKey = mkPreludeDataConUnique 26 -stateAndByteArrayPrimDataConKey = mkPreludeDataConUnique 27 -stateAndCharPrimDataConKey = mkPreludeDataConUnique 28 -stateAndDoublePrimDataConKey = mkPreludeDataConUnique 29 -stateAndFloatPrimDataConKey = mkPreludeDataConUnique 30 -stateAndIntPrimDataConKey = mkPreludeDataConUnique 31 -stateAndForeignObjPrimDataConKey = mkPreludeDataConUnique 32 -stateAndMutableArrayPrimDataConKey = mkPreludeDataConUnique 33 -stateAndMutableByteArrayPrimDataConKey = mkPreludeDataConUnique 34 -stateAndSynchVarPrimDataConKey = mkPreludeDataConUnique 35 -stateAndPtrPrimDataConKey = mkPreludeDataConUnique 36 -stateAndStablePtrPrimDataConKey = mkPreludeDataConUnique 37 -stateAndWordPrimDataConKey = mkPreludeDataConUnique 38 -stateDataConKey = mkPreludeDataConUnique 39 -trueDataConKey = mkPreludeDataConUnique 40 -wordDataConKey = mkPreludeDataConUnique 41 -stDataConKey = mkPreludeDataConUnique 42 +foreignObjDataConKey = mkPreludeDataConUnique 13 +nilDataConKey = mkPreludeDataConUnique 14 +ratioDataConKey = mkPreludeDataConUnique 15 +stablePtrDataConKey = mkPreludeDataConUnique 16 +stateDataConKey = mkPreludeDataConUnique 33 +trueDataConKey = mkPreludeDataConUnique 34 +wordDataConKey = mkPreludeDataConUnique 35 +word8DataConKey = mkPreludeDataConUnique 36 +word16DataConKey = mkPreludeDataConUnique 37 +word32DataConKey = mkPreludeDataConUnique 38 +word64DataConKey = mkPreludeDataConUnique 39 +stDataConKey = mkPreludeDataConUnique 40 +ioDataConKey = mkPreludeDataConUnique 42 \end{code} %************************************************************************ @@ -604,82 +584,74 @@ stDataConKey = mkPreludeDataConUnique 42 \begin{code} absentErrorIdKey = mkPreludeMiscIdUnique 1 -andandIdKey = mkPreludeMiscIdUnique 2 -appendIdKey = mkPreludeMiscIdUnique 3 -augmentIdKey = mkPreludeMiscIdUnique 4 -buildIdKey = mkPreludeMiscIdUnique 5 -composeIdKey = mkPreludeMiscIdUnique 6 -errorIdKey = mkPreludeMiscIdUnique 7 -foldlIdKey = mkPreludeMiscIdUnique 8 -foldrIdKey = mkPreludeMiscIdUnique 9 -forkIdKey = mkPreludeMiscIdUnique 10 -int2IntegerIdKey = mkPreludeMiscIdUnique 11 -integerMinusOneIdKey = mkPreludeMiscIdUnique 12 -integerPlusOneIdKey = mkPreludeMiscIdUnique 13 -integerPlusTwoIdKey = mkPreludeMiscIdUnique 14 -integerZeroIdKey = mkPreludeMiscIdUnique 15 -irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16 -lexIdKey = mkPreludeMiscIdUnique 17 -noDefaultMethodErrorIdKey = mkPreludeMiscIdUnique 20 -nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21 -nonExplicitMethodErrorIdKey = mkPreludeMiscIdUnique 22 -notIdKey = mkPreludeMiscIdUnique 23 -packCStringIdKey = mkPreludeMiscIdUnique 24 -parErrorIdKey = mkPreludeMiscIdUnique 25 -parIdKey = mkPreludeMiscIdUnique 26 -patErrorIdKey = mkPreludeMiscIdUnique 27 -readParenIdKey = mkPreludeMiscIdUnique 28 -realWorldPrimIdKey = mkPreludeMiscIdUnique 29 -recConErrorIdKey = mkPreludeMiscIdUnique 30 -recUpdErrorIdKey = mkPreludeMiscIdUnique 31 -runSTIdKey = mkPreludeMiscIdUnique 32 -seqIdKey = mkPreludeMiscIdUnique 33 -showParenIdKey = mkPreludeMiscIdUnique 34 -showSpaceIdKey = mkPreludeMiscIdUnique 35 -showStringIdKey = mkPreludeMiscIdUnique 36 -traceIdKey = mkPreludeMiscIdUnique 37 -unpackCString2IdKey = mkPreludeMiscIdUnique 38 -unpackCStringAppendIdKey = mkPreludeMiscIdUnique 39 -unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 40 -unpackCStringIdKey = mkPreludeMiscIdUnique 41 -voidIdKey = mkPreludeMiscIdUnique 42 -ushowListIdKey = mkPreludeMiscIdUnique 43 -ureadListIdKey = mkPreludeMiscIdUnique 44 - -copyableIdKey = mkPreludeMiscIdUnique 45 -noFollowIdKey = mkPreludeMiscIdUnique 46 -parAtAbsIdKey = mkPreludeMiscIdUnique 47 -parAtForNowIdKey = mkPreludeMiscIdUnique 48 -parAtIdKey = mkPreludeMiscIdUnique 49 -parAtRelIdKey = mkPreludeMiscIdUnique 50 -parGlobalIdKey = mkPreludeMiscIdUnique 51 -parLocalIdKey = mkPreludeMiscIdUnique 52 +appendIdKey = mkPreludeMiscIdUnique 2 +augmentIdKey = mkPreludeMiscIdUnique 3 +buildIdKey = mkPreludeMiscIdUnique 4 +errorIdKey = mkPreludeMiscIdUnique 5 +foldlIdKey = mkPreludeMiscIdUnique 6 +foldrIdKey = mkPreludeMiscIdUnique 7 +recSelErrIdKey = mkPreludeMiscIdUnique 8 +integerMinusOneIdKey = mkPreludeMiscIdUnique 9 +integerPlusOneIdKey = mkPreludeMiscIdUnique 10 +integerPlusTwoIdKey = mkPreludeMiscIdUnique 11 +integerZeroIdKey = mkPreludeMiscIdUnique 12 +int2IntegerIdKey = mkPreludeMiscIdUnique 13 +addr2IntegerIdKey = mkPreludeMiscIdUnique 14 +irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15 +lexIdKey = mkPreludeMiscIdUnique 16 +noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17 +nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18 +packCStringIdKey = mkPreludeMiscIdUnique 19 +parErrorIdKey = mkPreludeMiscIdUnique 20 +parIdKey = mkPreludeMiscIdUnique 21 +patErrorIdKey = mkPreludeMiscIdUnique 22 +realWorldPrimIdKey = mkPreludeMiscIdUnique 23 +recConErrorIdKey = mkPreludeMiscIdUnique 24 +recUpdErrorIdKey = mkPreludeMiscIdUnique 25 +traceIdKey = mkPreludeMiscIdUnique 26 +unpackCString2IdKey = mkPreludeMiscIdUnique 27 +unpackCStringAppendIdKey = mkPreludeMiscIdUnique 28 +unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 29 +unpackCStringIdKey = mkPreludeMiscIdUnique 30 +voidIdKey = mkPreludeMiscIdUnique 31 +ushowListIdKey = mkPreludeMiscIdUnique 32 +unsafeCoerceIdKey = mkPreludeMiscIdUnique 33 +concatIdKey = mkPreludeMiscIdUnique 34 +filterIdKey = mkPreludeMiscIdUnique 35 +zipIdKey = mkPreludeMiscIdUnique 36 +bindIOIdKey = mkPreludeMiscIdUnique 37 +deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 +makeStablePtrIdKey = mkPreludeMiscIdUnique 39 \end{code} -Certain class operations from Prelude classes. They get -their own uniques so we can look them up easily when we want -to conjure them up during type checking. +Certain class operations from Prelude classes. They get their own +uniques so we can look them up easily when we want to conjure them up +during type checking. + \begin{code} -fromIntClassOpKey = mkPreludeMiscIdUnique 53 -fromIntegerClassOpKey = mkPreludeMiscIdUnique 54 -minusClassOpKey = mkPreludeMiscIdUnique 69 -fromRationalClassOpKey = mkPreludeMiscIdUnique 55 -enumFromClassOpKey = mkPreludeMiscIdUnique 56 -enumFromThenClassOpKey = mkPreludeMiscIdUnique 57 -enumFromToClassOpKey = mkPreludeMiscIdUnique 58 -enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59 -eqClassOpKey = mkPreludeMiscIdUnique 60 -geClassOpKey = mkPreludeMiscIdUnique 61 -zeroClassOpKey = mkPreludeMiscIdUnique 62 -thenMClassOpKey = mkPreludeMiscIdUnique 63 -- (>>=) -unboundKey = mkPreludeMiscIdUnique 64 -- Just a place holder for unbound - -- variables produced by the renamer -fromEnumClassOpKey = mkPreludeMiscIdUnique 65 - -mainKey = mkPreludeMiscIdUnique 66 -mainPrimIoKey = mkPreludeMiscIdUnique 67 -returnMClassOpKey = mkPreludeMiscIdUnique 68 --- Used for minusClassOp 69 -otherwiseIdKey = mkPreludeMiscIdUnique 70 -toEnumClassOpKey = mkPreludeMiscIdUnique 71 +fromIntClassOpKey = mkPreludeMiscIdUnique 101 +fromIntegerClassOpKey = mkPreludeMiscIdUnique 102 +minusClassOpKey = mkPreludeMiscIdUnique 103 +fromRationalClassOpKey = mkPreludeMiscIdUnique 104 +enumFromClassOpKey = mkPreludeMiscIdUnique 105 +enumFromThenClassOpKey = mkPreludeMiscIdUnique 106 +enumFromToClassOpKey = mkPreludeMiscIdUnique 107 +enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108 +eqClassOpKey = mkPreludeMiscIdUnique 109 +geClassOpKey = mkPreludeMiscIdUnique 110 +zeroClassOpKey = mkPreludeMiscIdUnique 112 +thenMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) + -- Just a place holder for unbound variables produced by the renamer: +unboundKey = mkPreludeMiscIdUnique 114 +fromEnumClassOpKey = mkPreludeMiscIdUnique 115 + +mainKey = mkPreludeMiscIdUnique 116 +returnMClassOpKey = mkPreludeMiscIdUnique 117 +otherwiseIdKey = mkPreludeMiscIdUnique 118 +toEnumClassOpKey = mkPreludeMiscIdUnique 119 +mapIdKey = mkPreludeMiscIdUnique 120 +\end{code} + +\begin{code} +assertIdKey = mkPreludeMiscIdUnique 121 \end{code}