X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FbasicTypes%2FUnique.lhs;h=bdd8513ab9e0e6a1a4aa3e516560c6bde184af28;hb=ddc68ccc4c2efacf152b166cc40a0a592f90e399;hp=591b27ae9f05a2f1de796c94b4d062984404f8c0;hpb=dcef38bab91d45b56f7cf3ceeec96303d93728bb;p=ghc-hetmet.git diff --git a/ghc/compiler/basicTypes/Unique.lhs b/ghc/compiler/basicTypes/Unique.lhs index 591b27a..bdd8513 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,22 +45,25 @@ module Unique ( addrDataConKey, addrPrimTyConKey, addrTyConKey, - andandIdKey, appendIdKey, arrayPrimTyConKey, + assertIdKey, augmentIdKey, + bindIOIdKey, boolTyConKey, boundedClassKey, - buildDataConKey, + boxedConKey, buildIdKey, byteArrayPrimTyConKey, + byteArrayTyConKey, cCallableClassKey, cReturnableClassKey, charDataConKey, charPrimTyConKey, charTyConKey, - composeIdKey, + concatIdKey, consDataConKey, + deRefStablePtrIdKey, doubleDataConKey, doublePrimTyConKey, doubleTyConKey, @@ -72,10 +74,10 @@ module Unique ( enumFromToClassOpKey, eqClassKey, eqClassOpKey, - eqDataConKey, errorIdKey, - evalClassKey, falseDataConKey, + failMClassOpKey, + filterIdKey, floatDataConKey, floatPrimTyConKey, floatTyConKey, @@ -85,7 +87,6 @@ module Unique ( foreignObjDataConKey, foreignObjPrimTyConKey, foreignObjTyConKey, - forkIdKey, fractionalClassKey, fromEnumClassOpKey, fromIntClassOpKey, @@ -94,38 +95,45 @@ 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, + makeStablePtrIdKey, + mapIdKey, minusClassOpKey, monadClassKey, monadPlusClassKey, - monadZeroClassKey, mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, + mutableByteArrayTyConKey, + mutVarPrimTyConKey, nilDataConKey, - noDefaultMethodErrorIdKey, + noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey, - nonExplicitMethodErrorIdKey, - notIdKey, numClassKey, + anyBoxConKey, ordClassKey, orderingTyConKey, otherwiseIdKey, @@ -133,113 +141,71 @@ 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, + stableNameDataConKey, + stableNamePrimTyConKey, + stableNameTyConKey, + statePrimTyConKey, - stateTyConKey, - synchVarPrimTyConKey, + typeConKey, + kindConKey, + boxityConKey, + mVarPrimTyConKey, thenMClassOpKey, + threadIdPrimTyConKey, toEnumClassOpKey, traceIdKey, trueDataConKey, + unboundKey, + unboxedConKey, unpackCString2IdKey, unpackCStringAppendIdKey, unpackCStringFoldrIdKey, unpackCStringIdKey, - ureadListIdKey, + unsafeCoerceIdKey, ushowListIdKey, - voidIdKey, - voidTyConKey, + weakPrimTyConKey, wordDataConKey, wordPrimTyConKey, wordTyConKey, - zeroClassOpKey - , copyableIdKey - , noFollowIdKey - , parAtAbsIdKey - , parAtForNowIdKey - , parAtIdKey - , parAtRelIdKey - , parGlobalIdKey - , parLocalIdKey - , unboundKey - , byteArrayTyConKey - , mutableByteArrayTyConKey - , allClassKey + word8TyConKey, + word8DataConKey, + word16TyConKey, + word16DataConKey, + word32TyConKey, + word32DataConKey, + word64DataConKey, + word64PrimTyConKey, + word64TyConKey, + zipIdKey ) where -#if __GLASGOW_HASKELL__ <= 201 -import PreludeGlaST -#else +#include "HsVersions.h" + +import FastString ( FastString, uniqueOfFS ) import GlaExts import ST -#endif - -IMP_Ubiq(){-uitous-} - -#if __GLASGOW_HASKELL__ >= 202 -import {-# SOURCE #-} UniqFM ( Uniquable(..) ) -#endif +import PrelBase ( Char(..), chr, ord ) import Outputable -import Pretty -import Util \end{code} %************************************************************************ @@ -252,9 +218,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} @@ -267,6 +235,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} @@ -274,6 +244,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) @@ -294,9 +267,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@} @@ -313,7 +306,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 @@ -324,19 +317,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 -> Doc +pprUnique, pprUnique10 :: Unique -> SDoc pprUnique uniq = case unpkUnique uniq of @@ -346,28 +336,17 @@ pprUnique10 uniq -- in base-10, dudes = case unpkUnique uniq of (tag, u) -> finish_ppr tag u (int 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 -> char 'a' - 2 -> char 'b' - 3 -> char 'c' - 4 -> char 'd' - 5 -> char 'e' - _ -> pp_all - where - pp_all = (<>) (char tag) pp_u - -showUnique :: Unique -> FAST_STRING -showUnique uniq = _PK_ (show (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} %************************************************************************ @@ -380,27 +359,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__ == 201 -# define BYTE_ARRAY GHCbase.ByteArray -# define RUN_ST GHCbase.runST -# define AND_THEN >>= -# define AND_THEN_ >> -# define RETURN return -#elif __GLASGOW_HASKELL__ >= 202 # 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 -> Doc +iToBase62 :: Int -> SDoc iToBase62 n@(I# n#) = ASSERT(n >= 0) @@ -445,28 +410,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 @@ -484,27 +458,24 @@ 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 monadClassKey = mkPreludeClassUnique 8 -monadZeroClassKey = mkPreludeClassUnique 9 -monadPlusClassKey = mkPreludeClassUnique 10 -functorClassKey = mkPreludeClassUnique 11 -numClassKey = mkPreludeClassUnique 12 -ordClassKey = mkPreludeClassUnique 13 -readClassKey = mkPreludeClassUnique 14 -realClassKey = mkPreludeClassUnique 15 -realFloatClassKey = mkPreludeClassUnique 16 -realFracClassKey = mkPreludeClassUnique 17 -showClassKey = mkPreludeClassUnique 18 +monadPlusClassKey = mkPreludeClassUnique 9 +functorClassKey = mkPreludeClassUnique 10 +numClassKey = mkPreludeClassUnique 11 +ordClassKey = mkPreludeClassUnique 12 +readClassKey = mkPreludeClassUnique 13 +realClassKey = mkPreludeClassUnique 14 +realFloatClassKey = mkPreludeClassUnique 15 +realFracClassKey = mkPreludeClassUnique 16 +showClassKey = mkPreludeClassUnique 17 -cCallableClassKey = mkPreludeClassUnique 19 -cReturnableClassKey = mkPreludeClassUnique 20 +cCallableClassKey = mkPreludeClassUnique 18 +cReturnableClassKey = mkPreludeClassUnique 19 -ixClassKey = mkPreludeClassUnique 21 -allClassKey = mkPreludeClassUnique 22 -- Pseudo class used for universal quantification +ixClassKey = mkPreludeClassUnique 20 \end{code} %************************************************************************ @@ -526,48 +497,48 @@ 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 -mutableByteArrayTyConKey = mkPreludeTyConUnique 49 -stTyConKey = mkPreludeTyConUnique 50 -primIoTyConKey = mkPreludeTyConUnique 51 -byteArrayTyConKey = mkPreludeTyConUnique 52 -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 +statePrimTyConKey = mkPreludeTyConUnique 35 +stableNamePrimTyConKey = mkPreludeTyConUnique 50 +stableNameTyConKey = 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 +boxedConKey = mkPreludeTyConUnique 64 +unboxedConKey = mkPreludeTyConUnique 65 +anyBoxConKey = mkPreludeTyConUnique 66 +kindConKey = mkPreludeTyConUnique 67 +boxityConKey = mkPreludeTyConUnique 68 +typeConKey = mkPreludeTyConUnique 69 +threadIdPrimTyConKey = mkPreludeTyConUnique 70 \end{code} %************************************************************************ @@ -578,42 +549,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 +stableNameDataConKey = mkPreludeDataConUnique 17 +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} %************************************************************************ @@ -624,82 +583,73 @@ 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 +ushowListIdKey = mkPreludeMiscIdUnique 31 +unsafeCoerceIdKey = mkPreludeMiscIdUnique 32 +concatIdKey = mkPreludeMiscIdUnique 33 +filterIdKey = mkPreludeMiscIdUnique 34 +zipIdKey = mkPreludeMiscIdUnique 35 +bindIOIdKey = mkPreludeMiscIdUnique 36 +deRefStablePtrIdKey = mkPreludeMiscIdUnique 37 +makeStablePtrIdKey = mkPreludeMiscIdUnique 38 \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 +failMClassOpKey = 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}