X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FPrelNames.lhs;h=8dc8fb908a20d2772430a1921ccc227384ecbd19;hb=b085ee40c7f265a5977ea6ec1c415e573be5ff8c;hp=279a2c77acc3b473d763e1dd7b4ac5525395695c;hpb=8ba124fc8acf8e71849610df41d6bd94153cabab;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/PrelNames.lhs b/ghc/compiler/prelude/PrelNames.lhs index 279a2c7..8dc8fb9 100644 --- a/ghc/compiler/prelude/PrelNames.lhs +++ b/ghc/compiler/prelude/PrelNames.lhs @@ -19,7 +19,7 @@ module PrelNames ( -- So many that we export them all ----------------------------------------------------------- - knownKeyRdrNames, + knownKeyNames, mkTupNameStr, mkTupConRdrName, ------------------------------------------------------------ @@ -29,133 +29,192 @@ module PrelNames ( derivingOccurrences, -- For a given class C, this tells what other derivableClassKeys, -- things are needed as a result of a -- deriving(C) clause - numericTyKeys, cCallishTyKeys + numericTyKeys, cCallishTyKeys, + mkUnboundName, isUnboundName ) where #include "HsVersions.h" -import Module ( ModuleName, mkPrelModule, mkModuleName ) -import OccName ( NameSpace, varName, dataName, tcName, clsName ) -import RdrName ( RdrName, mkPreludeQual ) +import Module ( ModuleName, mkPrelModule, mkHomeModule, mkModuleName ) +import OccName ( NameSpace, UserFS, varName, dataName, tcName, clsName, + mkKindOccFS, mkOccFS + ) +import RdrName ( RdrName, mkOrig, mkUnqual ) import UniqFM import Unique ( Unique, Uniquable(..), hasKey, mkPreludeMiscIdUnique, mkPreludeDataConUnique, - mkPreludeTyConUnique, mkPreludeClassUnique + mkPreludeTyConUnique, mkPreludeClassUnique, + mkTupleTyConUnique ) import BasicTypes ( Boxity(..), Arity ) import UniqFM ( UniqFM, listToUFM ) +import Name ( Name, mkInternalName, mkKnownKeyExternalName, nameRdrName ) +import RdrName ( rdrNameOcc ) +import SrcLoc ( builtinSrcLoc, noSrcLoc ) import Util ( nOfThem ) import Panic ( panic ) +import FastString \end{code} %************************************************************************ %* * -\subsection{Known key RdrNames} +\subsection{Local Names} %* * %************************************************************************ -This section tells what the compiler knows about the -assocation of names with uniques. These ones are the *non* wired-in ones. -The wired in ones are defined in TysWiredIn etc. +This *local* name is used by the interactive stuff \begin{code} -knownKeyRdrNames :: [(RdrName, Unique)] -knownKeyRdrNames +itName uniq = mkInternalName uniq (mkOccFS varName FSLIT("it")) noSrcLoc +\end{code} + +\begin{code} +-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly +-- during compiler debugging. +mkUnboundName :: RdrName -> Name +mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) builtinSrcLoc + +isUnboundName :: Name -> Bool +isUnboundName name = name `hasKey` unboundKey +\end{code} + + +%************************************************************************ +%* * +\subsection{Known key Names} +%* * +%************************************************************************ + +This section tells what the compiler knows about the assocation of +names with uniques. These ones are the *non* wired-in ones. The +wired in ones are defined in TysWiredIn etc. + +\begin{code} +knownKeyNames :: [Name] +knownKeyNames = [ -- Type constructors (synonyms especially) - (ioTyCon_RDR, ioTyConKey) - , (main_RDR, mainKey) - , (orderingTyCon_RDR, orderingTyConKey) - , (rationalTyCon_RDR, rationalTyConKey) - , (ratioDataCon_RDR, ratioDataConKey) - , (ratioTyCon_RDR, ratioTyConKey) - , (byteArrayTyCon_RDR, byteArrayTyConKey) - , (mutableByteArrayTyCon_RDR, mutableByteArrayTyConKey) - , (foreignObjTyCon_RDR, foreignObjTyConKey) - , (bcoPrimTyCon_RDR, bcoPrimTyConKey) - , (stablePtrTyCon_RDR, stablePtrTyConKey) - , (stablePtrDataCon_RDR, stablePtrDataConKey) + ioTyConName, ioDataConName, + runMainName, + orderingTyConName, + rationalTyConName, + ratioDataConName, + ratioTyConName, + byteArrayTyConName, + mutableByteArrayTyConName, + foreignObjTyConName, + foreignPtrTyConName, + bcoPrimTyConName, + stablePtrTyConName, + stablePtrDataConName, -- Classes. *Must* include: -- classes that are grabbed by key (e.g., eqClassKey) -- classes in "Class.standardClassKeys" (quite a few) - , (eqClass_RDR, eqClassKey) -- mentioned, derivable - , (ordClass_RDR, ordClassKey) -- derivable - , (boundedClass_RDR, boundedClassKey) -- derivable - , (numClass_RDR, numClassKey) -- mentioned, numeric - , (enumClass_RDR, enumClassKey) -- derivable - , (monadClass_RDR, monadClassKey) - , (monadPlusClass_RDR, monadPlusClassKey) - , (functorClass_RDR, functorClassKey) - , (showClass_RDR, showClassKey) -- derivable - , (realClass_RDR, realClassKey) -- numeric - , (integralClass_RDR, integralClassKey) -- numeric - , (fractionalClass_RDR, fractionalClassKey) -- numeric - , (floatingClass_RDR, floatingClassKey) -- numeric - , (realFracClass_RDR, realFracClassKey) -- numeric - , (realFloatClass_RDR, realFloatClassKey) -- numeric - , (readClass_RDR, readClassKey) -- derivable - , (ixClass_RDR, ixClassKey) -- derivable (but it isn't Prelude.Ix; hmmm) - , (ccallableClass_RDR, cCallableClassKey) -- mentioned, ccallish - , (creturnableClass_RDR, cReturnableClassKey) -- mentioned, ccallish + eqClassName, -- mentioned, derivable + ordClassName, -- derivable + boundedClassName, -- derivable + numClassName, -- mentioned, numeric + enumClassName, -- derivable + monadClassName, + functorClassName, + showClassName, -- derivable + realClassName, -- numeric + integralClassName, -- numeric + fractionalClassName, -- numeric + floatingClassName, -- numeric + realFracClassName, -- numeric + realFloatClassName, -- numeric + readClassName, -- derivable + ixClassName, -- derivable (but it isn't Prelude.Ix; hmmm) + cCallableClassName, -- mentioned, ccallish + cReturnableClassName, -- mentioned, ccallish -- ClassOps - , (fromInt_RDR, fromIntClassOpKey) - , (fromInteger_RDR, fromIntegerClassOpKey) - , (ge_RDR, geClassOpKey) - , (minus_RDR, minusClassOpKey) - , (enumFrom_RDR, enumFromClassOpKey) - , (enumFromThen_RDR, enumFromThenClassOpKey) - , (enumFromTo_RDR, enumFromToClassOpKey) - , (enumFromThenTo_RDR, enumFromThenToClassOpKey) - , (fromEnum_RDR, fromEnumClassOpKey) - , (toEnum_RDR, toEnumClassOpKey) - , (eq_RDR, eqClassOpKey) - , (thenM_RDR, thenMClassOpKey) - , (returnM_RDR, returnMClassOpKey) - , (failM_RDR, failMClassOpKey) - , (fromRational_RDR, fromRationalClassOpKey) - - , (deRefStablePtr_RDR, deRefStablePtrIdKey) - , (makeStablePtr_RDR, makeStablePtrIdKey) - , (bindIO_RDR, bindIOIdKey) - , (returnIO_RDR, returnIOIdKey) + fromIntegerName, + negateName, + geName, + minusName, + enumFromName, + enumFromThenName, + enumFromToName, + enumFromThenToName, + fromEnumName, + toEnumName, + eqName, + thenMName, + bindMName, + returnMName, + failMName, + fromRationalName, + + -- not class methods, but overloaded (for parallel arrays) + enumFromToPName, + enumFromThenToPName, + + deRefStablePtrName, + newStablePtrName, + bindIOName, + thenIOName, + returnIOName, + failIOName, -- Strings and lists - , (map_RDR, mapIdKey) - , (append_RDR, appendIdKey) - , (unpackCString_RDR, unpackCStringIdKey) - , (unpackCStringAppend_RDR, unpackCStringAppendIdKey) - , (unpackCStringFoldr_RDR, unpackCStringFoldrIdKey) - , (unpackCStringUtf8_RDR, unpackCStringUtf8IdKey) + mapName, + appendName, + unpackCStringName, + unpackCStringAppendName, + unpackCStringFoldrName, + unpackCStringUtf8Name, -- List operations - , (concat_RDR, concatIdKey) - , (filter_RDR, filterIdKey) - , (zip_RDR, zipIdKey) - , (foldr_RDR, foldrIdKey) - , (build_RDR, buildIdKey) - , (augment_RDR, augmentIdKey) + concatName, + filterName, + zipName, + foldrName, + buildName, + augmentName, + + -- Parallel array operations + nullPName, + lengthPName, + replicatePName, + mapPName, + filterPName, + zipPName, + crossPName, + indexPName, + toPName, + bpermutePName, + bpermuteDftPName, + indexOfPName, -- FFI primitive types that are not wired-in. - , (int8TyCon_RDR, int8TyConKey) - , (int16TyCon_RDR, int16TyConKey) - , (int32TyCon_RDR, int32TyConKey) - , (int64TyCon_RDR, int64TyConKey) - , (word8TyCon_RDR, word8TyConKey) - , (word16TyCon_RDR, word16TyConKey) - , (word32TyCon_RDR, word32TyConKey) - , (word64TyCon_RDR, word64TyConKey) + int8TyConName, + int16TyConName, + int32TyConName, + int64TyConName, + word8TyConName, + word16TyConName, + word32TyConName, + word64TyConName, -- Others - , (otherwiseId_RDR, otherwiseIdKey) - , (plusInteger_RDR, plusIntegerIdKey) - , (timesInteger_RDR, timesIntegerIdKey) - , (eqString_RDR, eqStringIdKey) - , (assert_RDR, assertIdKey) - , (runSTRep_RDR, runSTRepIdKey) + unsafeCoerceName, + otherwiseIdName, + plusIntegerName, + timesIntegerName, + eqStringName, + assertName, + runSTRepName, + printName, + splitName, fstName, sndName, -- Used by splittery + + -- Others (needed for flattening and not mentioned before) + andName, + orName ] \end{code} @@ -168,42 +227,57 @@ knownKeyRdrNames \begin{code} pRELUDE_Name = mkModuleName "Prelude" -pREL_GHC_Name = mkModuleName "PrelGHC" -- Primitive types and values -pREL_BASE_Name = mkModuleName "PrelBase" -pREL_ENUM_Name = mkModuleName "PrelEnum" -pREL_SHOW_Name = mkModuleName "PrelShow" -pREL_READ_Name = mkModuleName "PrelRead" -pREL_NUM_Name = mkModuleName "PrelNum" -pREL_LIST_Name = mkModuleName "PrelList" -pREL_TUP_Name = mkModuleName "PrelTup" -pREL_PACK_Name = mkModuleName "PrelPack" -pREL_CONC_Name = mkModuleName "PrelConc" -pREL_IO_BASE_Name = mkModuleName "PrelIOBase" -pREL_ST_Name = mkModuleName "PrelST" -pREL_ARR_Name = mkModuleName "PrelArr" +gHC_PRIM_Name = mkModuleName "GHC.Prim" -- Primitive types and values +pREL_BASE_Name = mkModuleName "GHC.Base" +pREL_ENUM_Name = mkModuleName "GHC.Enum" +pREL_SHOW_Name = mkModuleName "GHC.Show" +pREL_READ_Name = mkModuleName "GHC.Read" +pREL_NUM_Name = mkModuleName "GHC.Num" +pREL_LIST_Name = mkModuleName "GHC.List" +pREL_PARR_Name = mkModuleName "GHC.PArr" +pREL_TUP_Name = mkModuleName "Data.Tuple" +pREL_PACK_Name = mkModuleName "GHC.Pack" +pREL_CONC_Name = mkModuleName "GHC.Conc" +pREL_IO_BASE_Name = mkModuleName "GHC.IOBase" +pREL_ST_Name = mkModuleName "GHC.ST" +pREL_ARR_Name = mkModuleName "GHC.Arr" pREL_BYTEARR_Name = mkModuleName "PrelByteArr" -pREL_FOREIGN_Name = mkModuleName "PrelForeign" -pREL_STABLE_Name = mkModuleName "PrelStable" -pREL_ADDR_Name = mkModuleName "PrelAddr" -pREL_ERR_Name = mkModuleName "PrelErr" -pREL_REAL_Name = mkModuleName "PrelReal" -pREL_FLOAT_Name = mkModuleName "PrelFloat" - -pREL_MAIN_Name = mkModuleName "PrelMain" -mAIN_Name = mkModuleName "Main" -iNT_Name = mkModuleName "Int" -wORD_Name = mkModuleName "Word" - -pREL_GHC = mkPrelModule pREL_GHC_Name -pREL_BASE = mkPrelModule pREL_BASE_Name -pREL_ADDR = mkPrelModule pREL_ADDR_Name -pREL_STABLE = mkPrelModule pREL_STABLE_Name -pREL_IO_BASE = mkPrelModule pREL_IO_BASE_Name -pREL_PACK = mkPrelModule pREL_PACK_Name -pREL_ERR = mkPrelModule pREL_ERR_Name -pREL_NUM = mkPrelModule pREL_NUM_Name -pREL_REAL = mkPrelModule pREL_REAL_Name -pREL_FLOAT = mkPrelModule pREL_FLOAT_Name +fOREIGN_PTR_Name = mkModuleName "Foreign.ForeignPtr" +pREL_STABLE_Name = mkModuleName "GHC.Stable" +pREL_ADDR_Name = mkModuleName "GHC.Addr" +pREL_PTR_Name = mkModuleName "GHC.Ptr" +pREL_ERR_Name = mkModuleName "GHC.Err" +pREL_REAL_Name = mkModuleName "GHC.Real" +pREL_FLOAT_Name = mkModuleName "GHC.Float" +pREL_TOP_HANDLER_Name = mkModuleName "GHC.TopHandler" +sYSTEM_IO_Name = mkModuleName "System.IO" + +rEAD_PREC_Name = mkModuleName "Text.ParserCombinators.ReadPrec" +lEX_Name = mkModuleName "Text.Read.Lex" + +mAIN_Name = mkModuleName "Main" +pREL_INT_Name = mkModuleName "GHC.Int" +pREL_WORD_Name = mkModuleName "GHC.Word" + +fOREIGNOBJ_Name = mkModuleName "ForeignObj" +aDDR_Name = mkModuleName "Addr" + +gLA_EXTS_Name = mkModuleName "GHC.Exts" + +gHC_PRIM = mkPrelModule gHC_PRIM_Name +pREL_BASE = mkPrelModule pREL_BASE_Name +pREL_ADDR = mkPrelModule pREL_ADDR_Name +pREL_PTR = mkPrelModule pREL_PTR_Name +pREL_STABLE = mkPrelModule pREL_STABLE_Name +pREL_IO_BASE = mkPrelModule pREL_IO_BASE_Name +pREL_PACK = mkPrelModule pREL_PACK_Name +pREL_ERR = mkPrelModule pREL_ERR_Name +pREL_NUM = mkPrelModule pREL_NUM_Name +pREL_REAL = mkPrelModule pREL_REAL_Name +pREL_FLOAT = mkPrelModule pREL_FLOAT_Name +pRELUDE = mkPrelModule pRELUDE_Name + +iNTERACTIVE = mkHomeModule (mkModuleName "$Interactive") \end{code} %************************************************************************ @@ -213,28 +287,42 @@ pREL_FLOAT = mkPrelModule pREL_FLOAT_Name %************************************************************************ \begin{code} -mkTupNameStr :: Boxity -> Int -> (ModuleName, FAST_STRING) +mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS) -mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()")) +mkTupNameStr Boxed 0 = (pREL_BASE_Name, FSLIT("()")) mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???" -mkTupNameStr Boxed 2 = (pREL_TUP_Name, _PK_ "(,)") -- not strictly necessary -mkTupNameStr Boxed 3 = (pREL_TUP_Name, _PK_ "(,,)") -- ditto -mkTupNameStr Boxed 4 = (pREL_TUP_Name, _PK_ "(,,,)") -- ditto -mkTupNameStr Boxed n = (pREL_TUP_Name, _PK_ ("(" ++ nOfThem (n-1) ',' ++ ")")) +mkTupNameStr Boxed 2 = (pREL_TUP_Name, mkFastString "(,)") -- not strictly necessary +mkTupNameStr Boxed 3 = (pREL_TUP_Name, mkFastString "(,,)") -- ditto +mkTupNameStr Boxed 4 = (pREL_TUP_Name, mkFastString "(,,,)") -- ditto +mkTupNameStr Boxed n = (pREL_TUP_Name, mkFastString ("(" ++ nOfThem (n-1) ',' ++ ")")) mkTupNameStr Unboxed 0 = panic "Name.mkUbxTupNameStr: 0 ???" -mkTupNameStr Unboxed 1 = (pREL_GHC_Name, _PK_ "(# #)") -- 1 and 0 both make sense!!! -mkTupNameStr Unboxed 2 = (pREL_GHC_Name, _PK_ "(#,#)") -mkTupNameStr Unboxed 3 = (pREL_GHC_Name, _PK_ "(#,,#)") -mkTupNameStr Unboxed 4 = (pREL_GHC_Name, _PK_ "(#,,,#)") -mkTupNameStr Unboxed n = (pREL_GHC_Name, _PK_ ("(#" ++ nOfThem (n-1) ',' ++ "#)")) +mkTupNameStr Unboxed 1 = (gHC_PRIM_Name, mkFastString "(# #)") -- 1 and 0 both make sense!!! +mkTupNameStr Unboxed 2 = (gHC_PRIM_Name, mkFastString "(#,#)") +mkTupNameStr Unboxed 3 = (gHC_PRIM_Name, mkFastString "(#,,#)") +mkTupNameStr Unboxed 4 = (gHC_PRIM_Name, mkFastString "(#,,,#)") +mkTupNameStr Unboxed n = (gHC_PRIM_Name, mkFastString ("(#" ++ nOfThem (n-1) ',' ++ "#)")) mkTupConRdrName :: NameSpace -> Boxity -> Arity -> RdrName mkTupConRdrName space boxity arity = case mkTupNameStr boxity arity of - (mod, occ) -> mkPreludeQual space mod occ + (mod, occ) -> mkOrig space mod occ \end{code} +%************************************************************************ +%* * +\subsection{Unqualified RdrNames} +%* * +%************************************************************************ + +\begin{code} +main_RDR_Unqual :: RdrName +main_RDR_Unqual = mkUnqual varName FSLIT("main") +-- Don't get a RdrName from PrelNames.mainName, because nameRdrName +-- gets an Orig RdrName, and we want a Qual or Unqual one. An Unqual +-- one will do fine. +\end{code} + %************************************************************************ %* * @@ -242,206 +330,381 @@ mkTupConRdrName space boxity arity = case mkTupNameStr boxity arity of %* * %************************************************************************ -These RdrNames are not really "built in", but some parts of the compiler -(notably the deriving mechanism) need to mention their names, and it's convenient -to write them all down in one place. +Many of these Names are not really "built in", but some parts of the +compiler (notably the deriving mechanism) need to mention their names, +and it's convenient to write them all down in one place. \begin{code} -main_RDR = varQual mAIN_Name SLIT("main") - --- Stuff from PrelGHC -funTyCon_RDR = tcQual pREL_GHC_Name SLIT("(->)") -ccallableClass_RDR = clsQual pREL_GHC_Name SLIT("CCallable") -creturnableClass_RDR = clsQual pREL_GHC_Name SLIT("CReturnable") +dollarMainName = varQual mAIN_Name FSLIT("$main") dollarMainKey +runMainName = varQual pREL_TOP_HANDLER_Name FSLIT("runMain") runMainKey + +-- Stuff from GHC.Prim +usOnceTyConName = kindQual FSLIT(".") usOnceTyConKey +usManyTyConName = kindQual FSLIT("!") usManyTyConKey +superKindName = kindQual FSLIT("KX") kindConKey +superBoxityName = kindQual FSLIT("BX") boxityConKey +liftedConName = kindQual FSLIT("*") liftedConKey +unliftedConName = kindQual FSLIT("#") unliftedConKey +openKindConName = kindQual FSLIT("?") anyBoxConKey +usageKindConName = kindQual FSLIT("$") usageConKey +typeConName = kindQual FSLIT("Type") typeConKey + +funTyConName = tcQual gHC_PRIM_Name FSLIT("(->)") funTyConKey +charPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Char#") charPrimTyConKey +intPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Int#") intPrimTyConKey +int32PrimTyConName = tcQual gHC_PRIM_Name FSLIT("Int32#") int32PrimTyConKey +int64PrimTyConName = tcQual gHC_PRIM_Name FSLIT("Int64#") int64PrimTyConKey +wordPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Word#") wordPrimTyConKey +word32PrimTyConName = tcQual gHC_PRIM_Name FSLIT("Word32#") word32PrimTyConKey +word64PrimTyConName = tcQual gHC_PRIM_Name FSLIT("Word64#") word64PrimTyConKey +addrPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Addr#") addrPrimTyConKey +floatPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Float#") floatPrimTyConKey +doublePrimTyConName = tcQual gHC_PRIM_Name FSLIT("Double#") doublePrimTyConKey +statePrimTyConName = tcQual gHC_PRIM_Name FSLIT("State#") statePrimTyConKey +realWorldTyConName = tcQual gHC_PRIM_Name FSLIT("RealWorld") realWorldTyConKey +arrayPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Array#") arrayPrimTyConKey +byteArrayPrimTyConName = tcQual gHC_PRIM_Name FSLIT("ByteArray#") byteArrayPrimTyConKey +mutableArrayPrimTyConName = tcQual gHC_PRIM_Name FSLIT("MutableArray#") mutableArrayPrimTyConKey +mutableByteArrayPrimTyConName = tcQual gHC_PRIM_Name FSLIT("MutableByteArray#") mutableByteArrayPrimTyConKey +mutVarPrimTyConName = tcQual gHC_PRIM_Name FSLIT("MutVar#") mutVarPrimTyConKey +mVarPrimTyConName = tcQual gHC_PRIM_Name FSLIT("MVar#") mVarPrimTyConKey +stablePtrPrimTyConName = tcQual gHC_PRIM_Name FSLIT("StablePtr#") stablePtrPrimTyConKey +stableNamePrimTyConName = tcQual gHC_PRIM_Name FSLIT("StableName#") stableNamePrimTyConKey +foreignObjPrimTyConName = tcQual gHC_PRIM_Name FSLIT("ForeignObj#") foreignObjPrimTyConKey +bcoPrimTyConName = tcQual gHC_PRIM_Name FSLIT("BCO#") bcoPrimTyConKey +weakPrimTyConName = tcQual gHC_PRIM_Name FSLIT("Weak#") weakPrimTyConKey +threadIdPrimTyConName = tcQual gHC_PRIM_Name FSLIT("ThreadId#") threadIdPrimTyConKey +cCallableClassName = clsQual gHC_PRIM_Name FSLIT("CCallable") cCallableClassKey +cReturnableClassName = clsQual gHC_PRIM_Name FSLIT("CReturnable") cReturnableClassKey -- PrelBase data types and constructors -charTyCon_RDR = tcQual pREL_BASE_Name SLIT("Char") -charDataCon_RDR = dataQual pREL_BASE_Name SLIT("C#") -intTyCon_RDR = tcQual pREL_BASE_Name SLIT("Int") -mkInt_RDR = dataQual pREL_BASE_Name SLIT("I#") -orderingTyCon_RDR = tcQual pREL_BASE_Name SLIT("Ordering") -boolTyCon_RDR = tcQual pREL_BASE_Name SLIT("Bool") -false_RDR = dataQual pREL_BASE_Name SLIT("False") -true_RDR = dataQual pREL_BASE_Name SLIT("True") -listTyCon_RDR = tcQual pREL_BASE_Name SLIT("[]") -nil_RDR = dataQual pREL_BASE_Name SLIT("[]") -cons_RDR = dataQual pREL_BASE_Name SLIT(":") +charTyConName = tcQual pREL_BASE_Name FSLIT("Char") charTyConKey +charDataConName = dataQual pREL_BASE_Name FSLIT("C#") charDataConKey +intTyConName = tcQual pREL_BASE_Name FSLIT("Int") intTyConKey +intDataConName = dataQual pREL_BASE_Name FSLIT("I#") intDataConKey +orderingTyConName = tcQual pREL_BASE_Name FSLIT("Ordering") orderingTyConKey +boolTyConName = tcQual pREL_BASE_Name FSLIT("Bool") boolTyConKey +falseDataConName = dataQual pREL_BASE_Name FSLIT("False") falseDataConKey +trueDataConName = dataQual pREL_BASE_Name FSLIT("True") trueDataConKey +listTyConName = tcQual pREL_BASE_Name FSLIT("[]") listTyConKey +nilDataConName = dataQual pREL_BASE_Name FSLIT("[]") nilDataConKey +consDataConName = dataQual pREL_BASE_Name FSLIT(":") consDataConKey + +-- PrelTup +fstName = varQual pREL_TUP_Name FSLIT("fst") fstIdKey +sndName = varQual pREL_TUP_Name FSLIT("snd") sndIdKey -- Generics -crossTyCon_RDR = tcQual pREL_BASE_Name SLIT(":*:") -crossDataCon_RDR = dataQual pREL_BASE_Name SLIT(":*:") -plusTyCon_RDR = tcQual pREL_BASE_Name SLIT(":+:") -inlDataCon_RDR = dataQual pREL_BASE_Name SLIT("Inl") -inrDataCon_RDR = dataQual pREL_BASE_Name SLIT("Inr") -genUnitTyCon_RDR = tcQual pREL_BASE_Name SLIT("Unit") -genUnitDataCon_RDR = dataQual pREL_BASE_Name SLIT("Unit") +crossTyConName = tcQual pREL_BASE_Name FSLIT(":*:") crossTyConKey +crossDataConName = dataQual pREL_BASE_Name FSLIT(":*:") crossDataConKey +plusTyConName = tcQual pREL_BASE_Name FSLIT(":+:") plusTyConKey +inlDataConName = dataQual pREL_BASE_Name FSLIT("Inl") inlDataConKey +inrDataConName = dataQual pREL_BASE_Name FSLIT("Inr") inrDataConKey +genUnitTyConName = tcQual pREL_BASE_Name FSLIT("Unit") genUnitTyConKey +genUnitDataConName = dataQual pREL_BASE_Name FSLIT("Unit") genUnitDataConKey -- Random PrelBase functions -otherwiseId_RDR = varQual pREL_BASE_Name SLIT("otherwise") -and_RDR = varQual pREL_BASE_Name SLIT("&&") -not_RDR = varQual pREL_BASE_Name SLIT("not") -compose_RDR = varQual pREL_BASE_Name SLIT(".") -append_RDR = varQual pREL_BASE_Name SLIT("++") -foldr_RDR = varQual pREL_BASE_Name SLIT("foldr") -map_RDR = varQual pREL_BASE_Name SLIT("map") -build_RDR = varQual pREL_BASE_Name SLIT("build") -augment_RDR = varQual pREL_BASE_Name SLIT("augment") -eqString_RDR = varQual pREL_BASE_Name SLIT("eqString") +unsafeCoerceName = varQual pREL_BASE_Name FSLIT("unsafeCoerce") + unsafeCoerceIdKey +otherwiseIdName = varQual pREL_BASE_Name FSLIT("otherwise") otherwiseIdKey +appendName = varQual pREL_BASE_Name FSLIT("++") appendIdKey +foldrName = varQual pREL_BASE_Name FSLIT("foldr") foldrIdKey +mapName = varQual pREL_BASE_Name FSLIT("map") mapIdKey +buildName = varQual pREL_BASE_Name FSLIT("build") buildIdKey +augmentName = varQual pREL_BASE_Name FSLIT("augment") augmentIdKey +eqStringName = varQual pREL_BASE_Name FSLIT("eqString") eqStringIdKey +andName = varQual pREL_BASE_Name FSLIT("&&") andIdKey +orName = varQual pREL_BASE_Name FSLIT("||") orIdKey -- Strings -unpackCString_RDR = varQual pREL_BASE_Name SLIT("unpackCString#") -unpackCStringAppend_RDR = varQual pREL_BASE_Name SLIT("unpackAppendCString#") -unpackCStringFoldr_RDR = varQual pREL_BASE_Name SLIT("unpackFoldrCString#") -unpackCStringUtf8_RDR = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#") +unpackCStringName = varQual pREL_BASE_Name FSLIT("unpackCString#") unpackCStringIdKey +unpackCStringAppendName = varQual pREL_BASE_Name FSLIT("unpackAppendCString#") unpackCStringAppendIdKey +unpackCStringFoldrName = varQual pREL_BASE_Name FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey +unpackCStringUtf8Name = varQual pREL_BASE_Name FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey -- Classes Eq and Ord -eqClass_RDR = clsQual pREL_BASE_Name SLIT("Eq") -ordClass_RDR = clsQual pREL_BASE_Name SLIT("Ord") -eq_RDR = varQual pREL_BASE_Name SLIT("==") -ne_RDR = varQual pREL_BASE_Name SLIT("/=") -le_RDR = varQual pREL_BASE_Name SLIT("<=") -lt_RDR = varQual pREL_BASE_Name SLIT("<") -ge_RDR = varQual pREL_BASE_Name SLIT(">=") -gt_RDR = varQual pREL_BASE_Name SLIT(">") -ltTag_RDR = dataQual pREL_BASE_Name SLIT("LT") -eqTag_RDR = dataQual pREL_BASE_Name SLIT("EQ") -gtTag_RDR = dataQual pREL_BASE_Name SLIT("GT") -max_RDR = varQual pREL_BASE_Name SLIT("max") -min_RDR = varQual pREL_BASE_Name SLIT("min") -compare_RDR = varQual pREL_BASE_Name SLIT("compare") +eqClassName = clsQual pREL_BASE_Name FSLIT("Eq") eqClassKey +ordClassName = clsQual pREL_BASE_Name FSLIT("Ord") ordClassKey +eqName = varQual pREL_BASE_Name FSLIT("==") eqClassOpKey +geName = varQual pREL_BASE_Name FSLIT(">=") geClassOpKey -- Class Monad -monadClass_RDR = clsQual pREL_BASE_Name SLIT("Monad") -monadPlusClass_RDR = clsQual pREL_BASE_Name SLIT("MonadPlus") -thenM_RDR = varQual pREL_BASE_Name SLIT(">>=") -returnM_RDR = varQual pREL_BASE_Name SLIT("return") -failM_RDR = varQual pREL_BASE_Name SLIT("fail") +monadClassName = clsQual pREL_BASE_Name FSLIT("Monad") monadClassKey +thenMName = varQual pREL_BASE_Name FSLIT(">>") thenMClassOpKey +bindMName = varQual pREL_BASE_Name FSLIT(">>=") bindMClassOpKey +returnMName = varQual pREL_BASE_Name FSLIT("return") returnMClassOpKey +failMName = varQual pREL_BASE_Name FSLIT("fail") failMClassOpKey -- Class Functor -functorClass_RDR = clsQual pREL_BASE_Name SLIT("Functor") +functorClassName = clsQual pREL_BASE_Name FSLIT("Functor") functorClassKey -- Class Show -showClass_RDR = clsQual pREL_SHOW_Name SLIT("Show") -showList___RDR = varQual pREL_SHOW_Name SLIT("showList__") -showsPrec_RDR = varQual pREL_SHOW_Name SLIT("showsPrec") -showList_RDR = varQual pREL_SHOW_Name SLIT("showList") -showSpace_RDR = varQual pREL_SHOW_Name SLIT("showSpace") -showString_RDR = varQual pREL_SHOW_Name SLIT("showString") -showParen_RDR = varQual pREL_SHOW_Name SLIT("showParen") +showClassName = clsQual pREL_SHOW_Name FSLIT("Show") showClassKey -- Class Read -readClass_RDR = clsQual pREL_READ_Name SLIT("Read") -readsPrec_RDR = varQual pREL_READ_Name SLIT("readsPrec") -readList_RDR = varQual pREL_READ_Name SLIT("readList") -readParen_RDR = varQual pREL_READ_Name SLIT("readParen") -lex_RDR = varQual pREL_READ_Name SLIT("lex") -readList___RDR = varQual pREL_READ_Name SLIT("readList__") - +readClassName = clsQual pREL_READ_Name FSLIT("Read") readClassKey -- Module PrelNum -numClass_RDR = clsQual pREL_NUM_Name SLIT("Num") -fromInt_RDR = varQual pREL_NUM_Name SLIT("fromInt") -fromInteger_RDR = varQual pREL_NUM_Name SLIT("fromInteger") -minus_RDR = varQual pREL_NUM_Name SLIT("-") -negate_RDR = varQual pREL_NUM_Name SLIT("negate") -plus_RDR = varQual pREL_NUM_Name SLIT("+") -times_RDR = varQual pREL_NUM_Name SLIT("*") -plusInteger_RDR = varQual pREL_NUM_Name SLIT("plusInteger") -timesInteger_RDR = varQual pREL_NUM_Name SLIT("timesInteger") -integerTyCon_RDR = tcQual pREL_NUM_Name SLIT("Integer") -smallIntegerDataCon_RDR = dataQual pREL_NUM_Name SLIT("S#") -largeIntegerDataCon_RDR = dataQual pREL_NUM_Name SLIT("J#") +numClassName = clsQual pREL_NUM_Name FSLIT("Num") numClassKey +fromIntegerName = varQual pREL_NUM_Name FSLIT("fromInteger") fromIntegerClassOpKey +minusName = varQual pREL_NUM_Name FSLIT("-") minusClassOpKey +negateName = varQual pREL_NUM_Name FSLIT("negate") negateClassOpKey +plusIntegerName = varQual pREL_NUM_Name FSLIT("plusInteger") plusIntegerIdKey +timesIntegerName = varQual pREL_NUM_Name FSLIT("timesInteger") timesIntegerIdKey +integerTyConName = tcQual pREL_NUM_Name FSLIT("Integer") integerTyConKey +smallIntegerDataConName = dataQual pREL_NUM_Name FSLIT("S#") smallIntegerDataConKey +largeIntegerDataConName = dataQual pREL_NUM_Name FSLIT("J#") largeIntegerDataConKey -- PrelReal types and classes -rationalTyCon_RDR = tcQual pREL_REAL_Name SLIT("Rational") -ratioTyCon_RDR = tcQual pREL_REAL_Name SLIT("Ratio") -ratioDataCon_RDR = dataQual pREL_REAL_Name SLIT(":%") -realClass_RDR = clsQual pREL_REAL_Name SLIT("Real") -integralClass_RDR = clsQual pREL_REAL_Name SLIT("Integral") -realFracClass_RDR = clsQual pREL_REAL_Name SLIT("RealFrac") -fractionalClass_RDR = clsQual pREL_REAL_Name SLIT("Fractional") -fromRational_RDR = varQual pREL_REAL_Name SLIT("fromRational") +rationalTyConName = tcQual pREL_REAL_Name FSLIT("Rational") rationalTyConKey +ratioTyConName = tcQual pREL_REAL_Name FSLIT("Ratio") ratioTyConKey +ratioDataConName = dataQual pREL_REAL_Name FSLIT(":%") ratioDataConKey +realClassName = clsQual pREL_REAL_Name FSLIT("Real") realClassKey +integralClassName = clsQual pREL_REAL_Name FSLIT("Integral") integralClassKey +realFracClassName = clsQual pREL_REAL_Name FSLIT("RealFrac") realFracClassKey +fractionalClassName = clsQual pREL_REAL_Name FSLIT("Fractional") fractionalClassKey +fromRationalName = varQual pREL_REAL_Name FSLIT("fromRational") fromRationalClassOpKey -- PrelFloat classes -floatTyCon_RDR = tcQual pREL_FLOAT_Name SLIT("Float") -floatDataCon_RDR = dataQual pREL_FLOAT_Name SLIT("F#") -doubleTyCon_RDR = tcQual pREL_FLOAT_Name SLIT("Double") -doubleDataCon_RDR = dataQual pREL_FLOAT_Name SLIT("D#") -floatingClass_RDR = clsQual pREL_FLOAT_Name SLIT("Floating") -realFloatClass_RDR = clsQual pREL_FLOAT_Name SLIT("RealFloat") +floatTyConName = tcQual pREL_FLOAT_Name FSLIT("Float") floatTyConKey +floatDataConName = dataQual pREL_FLOAT_Name FSLIT("F#") floatDataConKey +doubleTyConName = tcQual pREL_FLOAT_Name FSLIT("Double") doubleTyConKey +doubleDataConName = dataQual pREL_FLOAT_Name FSLIT("D#") doubleDataConKey +floatingClassName = clsQual pREL_FLOAT_Name FSLIT("Floating") floatingClassKey +realFloatClassName = clsQual pREL_FLOAT_Name FSLIT("RealFloat") realFloatClassKey -- Class Ix -ixClass_RDR = clsQual pREL_ARR_Name SLIT("Ix") -range_RDR = varQual pREL_ARR_Name SLIT("range") -index_RDR = varQual pREL_ARR_Name SLIT("index") -inRange_RDR = varQual pREL_ARR_Name SLIT("inRange") +ixClassName = clsQual pREL_ARR_Name FSLIT("Ix") ixClassKey -- Class Enum -enumClass_RDR = clsQual pREL_ENUM_Name SLIT("Enum") -succ_RDR = varQual pREL_ENUM_Name SLIT("succ") -pred_RDR = varQual pREL_ENUM_Name SLIT("pred") -toEnum_RDR = varQual pREL_ENUM_Name SLIT("toEnum") -fromEnum_RDR = varQual pREL_ENUM_Name SLIT("fromEnum") -enumFrom_RDR = varQual pREL_ENUM_Name SLIT("enumFrom") -enumFromTo_RDR = varQual pREL_ENUM_Name SLIT("enumFromTo") -enumFromThen_RDR = varQual pREL_ENUM_Name SLIT("enumFromThen") -enumFromThenTo_RDR = varQual pREL_ENUM_Name SLIT("enumFromThenTo") +enumClassName = clsQual pREL_ENUM_Name FSLIT("Enum") enumClassKey +toEnumName = varQual pREL_ENUM_Name FSLIT("toEnum") toEnumClassOpKey +fromEnumName = varQual pREL_ENUM_Name FSLIT("fromEnum") fromEnumClassOpKey +enumFromName = varQual pREL_ENUM_Name FSLIT("enumFrom") enumFromClassOpKey +enumFromToName = varQual pREL_ENUM_Name FSLIT("enumFromTo") enumFromToClassOpKey +enumFromThenName = varQual pREL_ENUM_Name FSLIT("enumFromThen") enumFromThenClassOpKey +enumFromThenToName = varQual pREL_ENUM_Name FSLIT("enumFromThenTo") enumFromThenToClassOpKey + +-- Overloaded via Class Enum +enumFromToPName = varQual pREL_PARR_Name FSLIT("enumFromToP") enumFromToPIdKey +enumFromThenToPName= varQual pREL_PARR_Name FSLIT("enumFromThenToP") enumFromThenToPIdKey -- Class Bounded -boundedClass_RDR = clsQual pREL_ENUM_Name SLIT("Bounded") -minBound_RDR = varQual pREL_ENUM_Name SLIT("minBound") -maxBound_RDR = varQual pREL_ENUM_Name SLIT("maxBound") - +boundedClassName = clsQual pREL_ENUM_Name FSLIT("Bounded") boundedClassKey -- List functions -concat_RDR = varQual pREL_LIST_Name SLIT("concat") -filter_RDR = varQual pREL_LIST_Name SLIT("filter") -zip_RDR = varQual pREL_LIST_Name SLIT("zip") +concatName = varQual pREL_LIST_Name FSLIT("concat") concatIdKey +filterName = varQual pREL_LIST_Name FSLIT("filter") filterIdKey +zipName = varQual pREL_LIST_Name FSLIT("zip") zipIdKey + +-- parallel array types and functions +parrTyConName = tcQual pREL_PARR_Name FSLIT("[::]") parrTyConKey +parrDataConName = dataQual pREL_PARR_Name FSLIT("PArr") parrDataConKey +nullPName = varQual pREL_PARR_Name FSLIT("nullP") nullPIdKey +lengthPName = varQual pREL_PARR_Name FSLIT("lengthP") lengthPIdKey +replicatePName = varQual pREL_PARR_Name FSLIT("replicateP") replicatePIdKey +mapPName = varQual pREL_PARR_Name FSLIT("mapP") mapPIdKey +filterPName = varQual pREL_PARR_Name FSLIT("filterP") filterPIdKey +zipPName = varQual pREL_PARR_Name FSLIT("zipP") zipPIdKey +crossPName = varQual pREL_PARR_Name FSLIT("crossP") crossPIdKey +indexPName = varQual pREL_PARR_Name FSLIT("!:") indexPIdKey +toPName = varQual pREL_PARR_Name FSLIT("toP") toPIdKey +bpermutePName = varQual pREL_PARR_Name FSLIT("bpermuteP") bpermutePIdKey +bpermuteDftPName = varQual pREL_PARR_Name FSLIT("bpermuteDftP") + bpermuteDftPIdKey +indexOfPName = varQual pREL_PARR_Name FSLIT("indexOfP") indexOfPIdKey -- IOBase things -ioTyCon_RDR = tcQual pREL_IO_BASE_Name SLIT("IO") -ioDataCon_RDR = dataQual pREL_IO_BASE_Name SLIT("IO") -bindIO_RDR = varQual pREL_IO_BASE_Name SLIT("bindIO") -returnIO_RDR = varQual pREL_IO_BASE_Name SLIT("returnIO") +ioTyConName = tcQual pREL_IO_BASE_Name FSLIT("IO") ioTyConKey +ioDataConName = dataQual pREL_IO_BASE_Name FSLIT("IO") ioDataConKey +thenIOName = varQual pREL_IO_BASE_Name FSLIT("thenIO") thenIOIdKey +bindIOName = varQual pREL_IO_BASE_Name FSLIT("bindIO") bindIOIdKey +returnIOName = varQual pREL_IO_BASE_Name FSLIT("returnIO") returnIOIdKey +failIOName = varQual pREL_IO_BASE_Name FSLIT("failIO") failIOIdKey + +-- IO things +printName = varQual sYSTEM_IO_Name FSLIT("print") printIdKey -- Int, Word, and Addr things -int8TyCon_RDR = tcQual iNT_Name SLIT("Int8") -int16TyCon_RDR = tcQual iNT_Name SLIT("Int16") -int32TyCon_RDR = tcQual iNT_Name SLIT("Int32") -int64TyCon_RDR = tcQual pREL_ADDR_Name SLIT("Int64") +int8TyConName = tcQual pREL_INT_Name FSLIT("Int8") int8TyConKey +int16TyConName = tcQual pREL_INT_Name FSLIT("Int16") int16TyConKey +int32TyConName = tcQual pREL_INT_Name FSLIT("Int32") int32TyConKey +int64TyConName = tcQual pREL_INT_Name FSLIT("Int64") int64TyConKey -wordTyCon_RDR = tcQual pREL_ADDR_Name SLIT("Word") -wordDataCon_RDR = dataQual pREL_ADDR_Name SLIT("W#") -word8TyCon_RDR = tcQual wORD_Name SLIT("Word8") -word16TyCon_RDR = tcQual wORD_Name SLIT("Word16") -word32TyCon_RDR = tcQual wORD_Name SLIT("Word32") -word64TyCon_RDR = tcQual pREL_ADDR_Name SLIT("Word64") +word8TyConName = tcQual pREL_WORD_Name FSLIT("Word8") word8TyConKey +word16TyConName = tcQual pREL_WORD_Name FSLIT("Word16") word16TyConKey +word32TyConName = tcQual pREL_WORD_Name FSLIT("Word32") word32TyConKey +word64TyConName = tcQual pREL_WORD_Name FSLIT("Word64") word64TyConKey -addrTyCon_RDR = tcQual pREL_ADDR_Name SLIT("Addr") -addrDataCon_RDR = dataQual pREL_ADDR_Name SLIT("A#") +wordTyConName = tcQual pREL_WORD_Name FSLIT("Word") wordTyConKey +wordDataConName = dataQual pREL_WORD_Name FSLIT("W#") wordDataConKey +addrTyConName = tcQual aDDR_Name FSLIT("Addr") addrTyConKey +addrDataConName = dataQual aDDR_Name FSLIT("A#") addrDataConKey + +ptrTyConName = tcQual pREL_PTR_Name FSLIT("Ptr") ptrTyConKey +ptrDataConName = dataQual pREL_PTR_Name FSLIT("Ptr") ptrDataConKey + +funPtrTyConName = tcQual pREL_PTR_Name FSLIT("FunPtr") funPtrTyConKey +funPtrDataConName = dataQual pREL_PTR_Name FSLIT("FunPtr") funPtrDataConKey -- Byte array types -byteArrayTyCon_RDR = tcQual pREL_BYTEARR_Name SLIT("ByteArray") -mutableByteArrayTyCon_RDR = tcQual pREL_BYTEARR_Name SLIT("MutableByteArray") - --- Forign objects and weak pointers -foreignObjTyCon_RDR = tcQual pREL_IO_BASE_Name SLIT("ForeignObj") -foreignObjDataCon_RDR = dataQual pREL_IO_BASE_Name SLIT("ForeignObj") -bcoPrimTyCon_RDR = tcQual pREL_BASE_Name SLIT("BCO#") -stablePtrTyCon_RDR = tcQual pREL_STABLE_Name SLIT("StablePtr") -stablePtrDataCon_RDR = dataQual pREL_STABLE_Name SLIT("StablePtr") -deRefStablePtr_RDR = varQual pREL_STABLE_Name SLIT("deRefStablePtr") -makeStablePtr_RDR = varQual pREL_STABLE_Name SLIT("makeStablePtr") - -error_RDR = varQual pREL_ERR_Name SLIT("error") -assert_RDR = varQual pREL_GHC_Name SLIT("assert") -getTag_RDR = varQual pREL_GHC_Name SLIT("getTag#") -assertErr_RDR = varQual pREL_ERR_Name SLIT("assertError") -runSTRep_RDR = varQual pREL_ST_Name SLIT("runSTRep") +byteArrayTyConName = tcQual pREL_BYTEARR_Name FSLIT("ByteArray") byteArrayTyConKey +mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name FSLIT("MutableByteArray") mutableByteArrayTyConKey + +-- Foreign objects and weak pointers +foreignObjTyConName = tcQual fOREIGNOBJ_Name FSLIT("ForeignObj") foreignObjTyConKey +foreignObjDataConName = dataQual fOREIGNOBJ_Name FSLIT("ForeignObj") foreignObjDataConKey +foreignPtrTyConName = tcQual fOREIGN_PTR_Name FSLIT("ForeignPtr") foreignPtrTyConKey +foreignPtrDataConName = dataQual fOREIGN_PTR_Name FSLIT("ForeignPtr") foreignPtrDataConKey +stablePtrTyConName = tcQual pREL_STABLE_Name FSLIT("StablePtr") stablePtrTyConKey +stablePtrDataConName = dataQual pREL_STABLE_Name FSLIT("StablePtr") stablePtrDataConKey +deRefStablePtrName = varQual pREL_STABLE_Name FSLIT("deRefStablePtr") deRefStablePtrIdKey +newStablePtrName = varQual pREL_STABLE_Name FSLIT("newStablePtr") newStablePtrIdKey + +assertName = varQual gHC_PRIM_Name FSLIT("assert") assertIdKey +getTagName = varQual gHC_PRIM_Name FSLIT("getTag#") getTagIdKey + +errorName = varQual pREL_ERR_Name FSLIT("error") errorIdKey +runSTRepName = varQual pREL_ST_Name FSLIT("runSTRep") runSTRepIdKey + +-- The "split" Id for splittable implicit parameters +splitName = varQual gLA_EXTS_Name FSLIT("split") splitIdKey +\end{code} +%************************************************************************ +%* * +\subsection{Known names} +%* * +%************************************************************************ + +The following names are known to the compiler, but they don't require +pre-assigned keys. Mostly these names are used in generating deriving +code, which is passed through the renamer anyway. + + THEY ARE ALL ORIGINAL NAMES, HOWEVER + +\begin{code} +-- Lists and tuples +tupleCon_RDR, tupleTyCon_RDR :: Int -> RdrName +ubxTupleCon_RDR, ubxTupleTyCon_RDR :: Int -> RdrName + +tupleCon_RDR = mkTupConRdrName dataName Boxed +tupleTyCon_RDR = mkTupConRdrName tcName Boxed +ubxTupleCon_RDR = mkTupConRdrName dataName Unboxed +ubxTupleTyCon_RDR = mkTupConRdrName tcName Unboxed + +unitCon_RDR = dataQual_RDR pREL_BASE_Name FSLIT("()") +unitTyCon_RDR = tcQual_RDR pREL_BASE_Name FSLIT("()") + +and_RDR = varQual_RDR pREL_BASE_Name FSLIT("&&") +not_RDR = varQual_RDR pREL_BASE_Name FSLIT("not") +compose_RDR = varQual_RDR pREL_BASE_Name FSLIT(".") +ne_RDR = varQual_RDR pREL_BASE_Name FSLIT("/=") +le_RDR = varQual_RDR pREL_BASE_Name FSLIT("<=") +lt_RDR = varQual_RDR pREL_BASE_Name FSLIT("<") +gt_RDR = varQual_RDR pREL_BASE_Name FSLIT(">") +ltTag_RDR = dataQual_RDR pREL_BASE_Name FSLIT("LT") +eqTag_RDR = dataQual_RDR pREL_BASE_Name FSLIT("EQ") +gtTag_RDR = dataQual_RDR pREL_BASE_Name FSLIT("GT") +max_RDR = varQual_RDR pREL_BASE_Name FSLIT("max") +min_RDR = varQual_RDR pREL_BASE_Name FSLIT("min") +compare_RDR = varQual_RDR pREL_BASE_Name FSLIT("compare") +showList_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showList") +showList___RDR = varQual_RDR pREL_SHOW_Name FSLIT("showList__") +showsPrec_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showsPrec") +showSpace_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showSpace") +showString_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showString") +showParen_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showParen") + +readsPrec_RDR = varQual_RDR pREL_READ_Name FSLIT("readsPrec") +readPrec_RDR = varQual_RDR pREL_READ_Name FSLIT("readPrec") +readListPrec_RDR = varQual_RDR pREL_READ_Name FSLIT("readListPrec") +readList_RDR = varQual_RDR pREL_READ_Name FSLIT("readList") + +readListDefault_RDR = varQual_RDR pREL_READ_Name FSLIT("readListDefault") +readListPrecDefault_RDR = varQual_RDR pREL_READ_Name FSLIT("readListPrecDefault") +parens_RDR = varQual_RDR pREL_READ_Name FSLIT("parens") +choose_RDR = varQual_RDR pREL_READ_Name FSLIT("choose") +lexP_RDR = varQual_RDR pREL_READ_Name FSLIT("lexP") + +-- Module ReadPrec +step_RDR = varQual_RDR rEAD_PREC_Name FSLIT("step") +reset_RDR = varQual_RDR rEAD_PREC_Name FSLIT("reset") +alt_RDR = varQual_RDR rEAD_PREC_Name FSLIT("+++") +prec_RDR = varQual_RDR rEAD_PREC_Name FSLIT("prec") + +-- Module Lex +symbol_RDR = dataQual_RDR lEX_Name FSLIT("Symbol") +ident_RDR = dataQual_RDR lEX_Name FSLIT("Ident") +single_RDR = dataQual_RDR lEX_Name FSLIT("Single") + +times_RDR = varQual_RDR pREL_NUM_Name FSLIT("*") +plus_RDR = varQual_RDR pREL_NUM_Name FSLIT("+") +negate_RDR = varQual_RDR pREL_NUM_Name FSLIT("negate") +range_RDR = varQual_RDR pREL_ARR_Name FSLIT("range") +index_RDR = varQual_RDR pREL_ARR_Name FSLIT("index") +inRange_RDR = varQual_RDR pREL_ARR_Name FSLIT("inRange") +succ_RDR = varQual_RDR pREL_ENUM_Name FSLIT("succ") +pred_RDR = varQual_RDR pREL_ENUM_Name FSLIT("pred") +minBound_RDR = varQual_RDR pREL_ENUM_Name FSLIT("minBound") +maxBound_RDR = varQual_RDR pREL_ENUM_Name FSLIT("maxBound") +assertErr_RDR = varQual_RDR pREL_ERR_Name FSLIT("assertError") \end{code} +These RDR names also have known keys, so we need to get back the RDR names to +populate the occurrence list above. + +\begin{code} +funTyCon_RDR = nameRdrName funTyConName +nilCon_RDR = nameRdrName nilDataConName +listTyCon_RDR = nameRdrName listTyConName +parrTyCon_RDR = nameRdrName parrTyConName +ioTyCon_RDR = nameRdrName ioTyConName +intTyCon_RDR = nameRdrName intTyConName +eq_RDR = nameRdrName eqName +ge_RDR = nameRdrName geName +numClass_RDR = nameRdrName numClassName +ordClass_RDR = nameRdrName ordClassName +map_RDR = nameRdrName mapName +append_RDR = nameRdrName appendName +foldr_RDR = nameRdrName foldrName +build_RDR = nameRdrName buildName +enumFromTo_RDR = nameRdrName enumFromToName +returnM_RDR = nameRdrName returnMName +bindM_RDR = nameRdrName bindMName +failM_RDR = nameRdrName failMName +false_RDR = nameRdrName falseDataConName +true_RDR = nameRdrName trueDataConName +error_RDR = nameRdrName errorName +getTag_RDR = nameRdrName getTagName +fromEnum_RDR = nameRdrName fromEnumName +toEnum_RDR = nameRdrName toEnumName +enumFrom_RDR = nameRdrName enumFromName +mkInt_RDR = nameRdrName intDataConName +enumFromThen_RDR = nameRdrName enumFromThenName +enumFromThenTo_RDR = nameRdrName enumFromThenToName +ratioDataCon_RDR = nameRdrName ratioDataConName +plusInteger_RDR = nameRdrName plusIntegerName +timesInteger_RDR = nameRdrName timesIntegerName +enumClass_RDR = nameRdrName enumClassName +monadClass_RDR = nameRdrName monadClassName +ioDataCon_RDR = nameRdrName ioDataConName +cCallableClass_RDR = nameRdrName cCallableClassName +cReturnableClass_RDR = nameRdrName cReturnableClassName +eqClass_RDR = nameRdrName eqClassName +eqString_RDR = nameRdrName eqStringName +unpackCString_RDR = nameRdrName unpackCStringName +unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName +unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name +deRefStablePtr_RDR = nameRdrName deRefStablePtrName +newStablePtr_RDR = nameRdrName newStablePtrName +bindIO_RDR = nameRdrName bindIOName +returnIO_RDR = nameRdrName returnIOName +fromInteger_RDR = nameRdrName fromIntegerName +fromRational_RDR = nameRdrName fromRationalName +minus_RDR = nameRdrName minusName +\end{code} %************************************************************************ %* * @@ -449,14 +712,25 @@ runSTRep_RDR = varQual pREL_ST_Name SLIT("runSTRep") %* * %************************************************************************ +All these are original names; hence mkOrig + \begin{code} -varQual = mkPreludeQual varName -dataQual = mkPreludeQual dataName -tcQual = mkPreludeQual tcName -clsQual = mkPreludeQual clsName +varQual mod str uq = mkKnownKeyExternalName (varQual_RDR mod str) uq +dataQual mod str uq = mkKnownKeyExternalName (dataQual_RDR mod str) uq +tcQual mod str uq = mkKnownKeyExternalName (tcQual_RDR mod str) uq +clsQual mod str uq = mkKnownKeyExternalName (clsQual_RDR mod str) uq + +kindQual str uq = mkInternalName uq (mkKindOccFS tcName str) builtinSrcLoc + -- Kinds are not z-encoded in interface file, hence mkKindOccFS + -- And they don't come from any particular module; indeed we always + -- want to print them unqualified. Hence the LocalName + +varQual_RDR mod str = mkOrig varName mod str +tcQual_RDR mod str = mkOrig tcName mod str +clsQual_RDR mod str = mkOrig clsName mod str +dataQual_RDR mod str = mkOrig dataName mod str \end{code} - %************************************************************************ %* * \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@} @@ -471,7 +745,6 @@ floatingClassKey = mkPreludeClassUnique 5 fractionalClassKey = mkPreludeClassUnique 6 integralClassKey = mkPreludeClassUnique 7 monadClassKey = mkPreludeClassUnique 8 -monadPlusClassKey = mkPreludeClassUnique 9 functorClassKey = mkPreludeClassUnique 10 numClassKey = mkPreludeClassUnique 11 ordClassKey = mkPreludeClassUnique 12 @@ -480,7 +753,7 @@ realClassKey = mkPreludeClassUnique 14 realFloatClassKey = mkPreludeClassUnique 15 realFracClassKey = mkPreludeClassUnique 16 showClassKey = mkPreludeClassUnique 17 - + cCallableClassKey = mkPreludeClassUnique 18 cReturnableClassKey = mkPreludeClassUnique 19 @@ -510,50 +783,65 @@ 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 -bcoPrimTyConKey = mkPreludeTyConUnique 71 +int32PrimTyConKey = mkPreludeTyConUnique 18 +int32TyConKey = mkPreludeTyConUnique 19 +int64PrimTyConKey = mkPreludeTyConUnique 20 +int64TyConKey = mkPreludeTyConUnique 21 +integerTyConKey = mkPreludeTyConUnique 22 +listTyConKey = mkPreludeTyConUnique 23 +foreignObjPrimTyConKey = mkPreludeTyConUnique 24 +foreignObjTyConKey = mkPreludeTyConUnique 25 +foreignPtrTyConKey = mkPreludeTyConUnique 26 +weakPrimTyConKey = mkPreludeTyConUnique 27 +mutableArrayPrimTyConKey = mkPreludeTyConUnique 28 +mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29 +orderingTyConKey = mkPreludeTyConUnique 30 +mVarPrimTyConKey = mkPreludeTyConUnique 31 +ratioTyConKey = mkPreludeTyConUnique 32 +rationalTyConKey = mkPreludeTyConUnique 33 +realWorldTyConKey = mkPreludeTyConUnique 34 +stablePtrPrimTyConKey = mkPreludeTyConUnique 35 +stablePtrTyConKey = mkPreludeTyConUnique 36 +statePrimTyConKey = mkPreludeTyConUnique 50 +stableNamePrimTyConKey = mkPreludeTyConUnique 51 +stableNameTyConKey = mkPreludeTyConUnique 52 +mutableByteArrayTyConKey = mkPreludeTyConUnique 53 +mutVarPrimTyConKey = mkPreludeTyConUnique 55 +ioTyConKey = mkPreludeTyConUnique 56 +byteArrayTyConKey = mkPreludeTyConUnique 57 +wordPrimTyConKey = mkPreludeTyConUnique 58 +wordTyConKey = mkPreludeTyConUnique 59 +word8TyConKey = mkPreludeTyConUnique 60 +word16TyConKey = mkPreludeTyConUnique 61 +word32PrimTyConKey = mkPreludeTyConUnique 62 +word32TyConKey = mkPreludeTyConUnique 63 +word64PrimTyConKey = mkPreludeTyConUnique 64 +word64TyConKey = mkPreludeTyConUnique 65 +liftedConKey = mkPreludeTyConUnique 66 +unliftedConKey = mkPreludeTyConUnique 67 +anyBoxConKey = mkPreludeTyConUnique 68 +kindConKey = mkPreludeTyConUnique 69 +boxityConKey = mkPreludeTyConUnique 70 +typeConKey = mkPreludeTyConUnique 71 +threadIdPrimTyConKey = mkPreludeTyConUnique 72 +bcoPrimTyConKey = mkPreludeTyConUnique 73 +ptrTyConKey = mkPreludeTyConUnique 74 +funPtrTyConKey = mkPreludeTyConUnique 75 + +-- Usage type constructors +usageConKey = mkPreludeTyConUnique 76 +usOnceTyConKey = mkPreludeTyConUnique 77 +usManyTyConKey = mkPreludeTyConUnique 78 -- Generic Type Constructors -crossTyConKey = mkPreludeTyConUnique 72 -plusTyConKey = mkPreludeTyConUnique 73 -genUnitTyConKey = mkPreludeTyConUnique 74 +crossTyConKey = mkPreludeTyConUnique 79 +plusTyConKey = mkPreludeTyConUnique 80 +genUnitTyConKey = mkPreludeTyConUnique 81 + +-- Parallel array type constructor +parrTyConKey = mkPreludeTyConUnique 82 + +unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} %************************************************************************ @@ -573,19 +861,25 @@ intDataConKey = mkPreludeDataConUnique 6 smallIntegerDataConKey = mkPreludeDataConUnique 7 largeIntegerDataConKey = mkPreludeDataConUnique 8 foreignObjDataConKey = mkPreludeDataConUnique 9 -nilDataConKey = mkPreludeDataConUnique 10 -ratioDataConKey = mkPreludeDataConUnique 11 -stablePtrDataConKey = mkPreludeDataConUnique 12 -stableNameDataConKey = mkPreludeDataConUnique 13 -trueDataConKey = mkPreludeDataConUnique 14 -wordDataConKey = mkPreludeDataConUnique 15 -ioDataConKey = mkPreludeDataConUnique 16 +foreignPtrDataConKey = mkPreludeDataConUnique 10 +nilDataConKey = mkPreludeDataConUnique 11 +ratioDataConKey = mkPreludeDataConUnique 12 +stablePtrDataConKey = mkPreludeDataConUnique 13 +stableNameDataConKey = mkPreludeDataConUnique 14 +trueDataConKey = mkPreludeDataConUnique 15 +wordDataConKey = mkPreludeDataConUnique 16 +ioDataConKey = mkPreludeDataConUnique 17 +ptrDataConKey = mkPreludeDataConUnique 18 +funPtrDataConKey = mkPreludeDataConUnique 19 -- Generic data constructors -crossDataConKey = mkPreludeDataConUnique 17 -inlDataConKey = mkPreludeDataConUnique 18 -inrDataConKey = mkPreludeDataConUnique 19 -genUnitDataConKey = mkPreludeDataConUnique 20 +crossDataConKey = mkPreludeDataConUnique 20 +inlDataConKey = mkPreludeDataConUnique 21 +inrDataConKey = mkPreludeDataConUnique 22 +genUnitDataConKey = mkPreludeDataConUnique 23 + +-- Data constructor for parallel arrays +parrDataConKey = mkPreludeDataConUnique 24 \end{code} %************************************************************************ @@ -608,10 +902,12 @@ integerPlusOneIdKey = mkPreludeMiscIdUnique 10 integerPlusTwoIdKey = mkPreludeMiscIdUnique 11 integerZeroIdKey = mkPreludeMiscIdUnique 12 int2IntegerIdKey = mkPreludeMiscIdUnique 13 +seqIdKey = mkPreludeMiscIdUnique 14 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15 eqStringIdKey = mkPreludeMiscIdUnique 16 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18 +runtimeErrorIdKey = mkPreludeMiscIdUnique 19 parErrorIdKey = mkPreludeMiscIdUnique 20 parIdKey = mkPreludeMiscIdUnique 21 patErrorIdKey = mkPreludeMiscIdUnique 22 @@ -631,18 +927,53 @@ zipIdKey = mkPreludeMiscIdUnique 35 bindIOIdKey = mkPreludeMiscIdUnique 36 returnIOIdKey = mkPreludeMiscIdUnique 37 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 -makeStablePtrIdKey = mkPreludeMiscIdUnique 39 +newStablePtrIdKey = mkPreludeMiscIdUnique 39 getTagIdKey = mkPreludeMiscIdUnique 40 plusIntegerIdKey = mkPreludeMiscIdUnique 41 timesIntegerIdKey = mkPreludeMiscIdUnique 42 +printIdKey = mkPreludeMiscIdUnique 43 +failIOIdKey = mkPreludeMiscIdUnique 44 +nullAddrIdKey = mkPreludeMiscIdUnique 46 +voidArgIdKey = mkPreludeMiscIdUnique 47 +splitIdKey = mkPreludeMiscIdUnique 48 +fstIdKey = mkPreludeMiscIdUnique 49 +sndIdKey = mkPreludeMiscIdUnique 50 +otherwiseIdKey = mkPreludeMiscIdUnique 51 +mapIdKey = mkPreludeMiscIdUnique 52 +assertIdKey = mkPreludeMiscIdUnique 53 +runSTRepIdKey = mkPreludeMiscIdUnique 54 + +dollarMainKey = mkPreludeMiscIdUnique 55 +runMainKey = mkPreludeMiscIdUnique 56 + +andIdKey = mkPreludeMiscIdUnique 57 +orIdKey = mkPreludeMiscIdUnique 58 +thenIOIdKey = mkPreludeMiscIdUnique 59 + +-- Parallel array functions +nullPIdKey = mkPreludeMiscIdUnique 70 +lengthPIdKey = mkPreludeMiscIdUnique 71 +replicatePIdKey = mkPreludeMiscIdUnique 72 +mapPIdKey = mkPreludeMiscIdUnique 73 +filterPIdKey = mkPreludeMiscIdUnique 74 +zipPIdKey = mkPreludeMiscIdUnique 75 +crossPIdKey = mkPreludeMiscIdUnique 76 +indexPIdKey = mkPreludeMiscIdUnique 77 +toPIdKey = mkPreludeMiscIdUnique 78 +enumFromToPIdKey = mkPreludeMiscIdUnique 79 +enumFromThenToPIdKey = mkPreludeMiscIdUnique 80 +bpermutePIdKey = mkPreludeMiscIdUnique 81 +bpermuteDftPIdKey = mkPreludeMiscIdUnique 82 +indexOfPIdKey = mkPreludeMiscIdUnique 83 \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. -\begin{code} -fromIntClassOpKey = mkPreludeMiscIdUnique 101 +\begin{code} + -- Just a place holder for unbound variables produced by the renamer: +unboundKey = mkPreludeMiscIdUnique 101 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102 minusClassOpKey = mkPreludeMiscIdUnique 103 fromRationalClassOpKey = mkPreludeMiscIdUnique 104 @@ -652,22 +983,13 @@ enumFromToClassOpKey = mkPreludeMiscIdUnique 107 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108 eqClassOpKey = mkPreludeMiscIdUnique 109 geClassOpKey = mkPreludeMiscIdUnique 110 +negateClassOpKey = mkPreludeMiscIdUnique 111 failMClassOpKey = mkPreludeMiscIdUnique 112 -thenMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) - -- Just a place holder for unbound variables produced by the renamer: -unboundKey = mkPreludeMiscIdUnique 114 +bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) +thenMClassOpKey = 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 -runSTRepIdKey = mkPreludeMiscIdUnique 122 \end{code} @@ -695,6 +1017,7 @@ cCallishTyKeys = , byteArrayTyConKey , mutableByteArrayTyConKey , foreignObjTyConKey + , foreignPtrTyConKey , stablePtrTyConKey , int8TyConKey , int16TyConKey @@ -717,14 +1040,16 @@ cCallishTyKeys = @derivableClassKeys@ is also used in checking \tr{deriving} constructs (@TcDeriv@). -@derivingOccurrences@ maps a class name to a list of the (qualified) occurrences -that will be mentioned by the derived code for the class when it is later generated. -We don't need to put in things that are WiredIn (because they are already mapped to their -correct name by the @NameSupply@. The class itself, and all its class ops, is -already flagged as an occurrence so we don't need to mention that either. +@derivingOccurrences@ maps a class name to a list of the (qualified) +occurrences that will be mentioned by the derived code for the class +when it is later generated. We don't need to put in things that are +WiredIn (because they are already mapped to their correct name by the +@NameSupply@. The class itself, and all its class ops, is already +flagged as an occurrence so we don't need to mention that either. -@derivingOccurrences@ has an item for every derivable class, even if that item is empty, -because we treat lookup failure as indicating that the class is illegal in a deriving clause. +@derivingOccurrences@ has an item for every derivable class, even if +that item is empty, because we treat lookup failure as indicating that +the class is illegal in a deriving clause. \begin{code} derivingOccurrences :: UniqFM [RdrName] @@ -734,25 +1059,25 @@ derivableClassKeys = map fst deriving_occ_info deriving_occ_info = [ (eqClassKey, [intTyCon_RDR, and_RDR, not_RDR]) - , (ordClassKey, [intTyCon_RDR, compose_RDR, eqTag_RDR]) + , (ordClassKey, [intTyCon_RDR, compose_RDR, eqTag_RDR, error_RDR]) -- EQ (from Ordering) is needed to force in the constructors -- as well as the type constructor. - , (enumClassKey, [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR]) + , (enumClassKey, [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, + error_RDR, showsPrec_RDR, append_RDR]) -- The last two Enum deps are only used to produce better -- error msgs for derived toEnum methods. , (boundedClassKey, [intTyCon_RDR]) , (showClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR, showParen_RDR, showSpace_RDR, showList___RDR]) - , (readClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR, - foldr_RDR, build_RDR, - -- foldr and build required for list comprehension - -- KSW 2000-06 - lex_RDR, readParen_RDR, readList___RDR, thenM_RDR]) - -- returnM (and the rest of the Monad class decl) - -- will be forced in as result of depending - -- on thenM. -- SOF 1/99 - , (ixClassKey, [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR, - foldr_RDR, build_RDR, + , (readClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, + lexP_RDR, readPrec_RDR, + readListDefault_RDR, readListPrecDefault_RDR, + step_RDR, parens_RDR, reset_RDR, prec_RDR, alt_RDR, choose_RDR, + ident_RDR, -- Pulls in the entire Lex.Lexeme data type + bindM_RDR -- Pulls in the entire Monad class decl + ] ) + , (ixClassKey, [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR, error_RDR, + foldr_RDR, build_RDR, -- foldr and build required for list comprehension used -- with single constructor types -- KSW 2000-06 returnM_RDR, failM_RDR])