X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FPrelNames.lhs;h=8dc8fb908a20d2772430a1921ccc227384ecbd19;hb=b085ee40c7f265a5977ea6ec1c415e573be5ff8c;hp=c2da0aa38c15bea3849293cbc29a7708e9f53f8e;hpb=51666a19707f4ca34eec28a14bffbbc7d642e647;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/PrelNames.lhs b/ghc/compiler/prelude/PrelNames.lhs index c2da0aa..8dc8fb9 100644 --- a/ghc/compiler/prelude/PrelNames.lhs +++ b/ghc/compiler/prelude/PrelNames.lhs @@ -49,11 +49,12 @@ import Unique ( Unique, Uniquable(..), hasKey, ) import BasicTypes ( Boxity(..), Arity ) import UniqFM ( UniqFM, listToUFM ) -import Name ( Name, mkLocalName, mkKnownKeyGlobal, nameRdrName ) +import Name ( Name, mkInternalName, mkKnownKeyExternalName, nameRdrName ) import RdrName ( rdrNameOcc ) import SrcLoc ( builtinSrcLoc, noSrcLoc ) import Util ( nOfThem ) import Panic ( panic ) +import FastString \end{code} @@ -66,14 +67,14 @@ import Panic ( panic ) This *local* name is used by the interactive stuff \begin{code} -itName uniq = mkLocalName uniq (mkOccFS varName SLIT("it")) noSrcLoc +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 = mkLocalName unboundKey (rdrNameOcc rdr_name) builtinSrcLoc +mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) builtinSrcLoc isUnboundName :: Name -> Bool isUnboundName name = name `hasKey` unboundKey @@ -95,8 +96,8 @@ knownKeyNames :: [Name] knownKeyNames = [ -- Type constructors (synonyms especially) - ioTyConName, - mainName, + ioTyConName, ioDataConName, + runMainName, orderingTyConName, rationalTyConName, ratioDataConName, @@ -118,7 +119,6 @@ knownKeyNames numClassName, -- mentioned, numeric enumClassName, -- derivable monadClassName, - monadPlusClassName, functorClassName, showClassName, -- derivable realClassName, -- numeric @@ -145,13 +145,19 @@ knownKeyNames toEnumName, eqName, thenMName, + bindMName, returnMName, failMName, fromRationalName, - + + -- not class methods, but overloaded (for parallel arrays) + enumFromToPName, + enumFromThenToPName, + deRefStablePtrName, newStablePtrName, bindIOName, + thenIOName, returnIOName, failIOName, @@ -159,7 +165,6 @@ knownKeyNames mapName, appendName, unpackCStringName, - unpackCStringListName, unpackCStringAppendName, unpackCStringFoldrName, unpackCStringUtf8Name, @@ -172,6 +177,20 @@ knownKeyNames 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. int8TyConName, int16TyConName, @@ -190,7 +209,12 @@ knownKeyNames eqStringName, assertName, runSTRepName, - printName + printName, + splitName, fstName, sndName, -- Used by splittery + + -- Others (needed for flattening and not mentioned before) + andName, + orName ] \end{code} @@ -203,38 +227,44 @@ knownKeyNames \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_IO_Name = mkModuleName "PrelIO" -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_PTR_Name = mkModuleName "PrelPtr" -pREL_ERR_Name = mkModuleName "PrelErr" -pREL_REAL_Name = mkModuleName "PrelReal" -pREL_FLOAT_Name = mkModuleName "PrelFloat" - -pREL_MAIN_Name = mkModuleName "PrelMain" +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 "PrelInt" -pREL_WORD_Name = mkModuleName "PrelWord" +pREL_INT_Name = mkModuleName "GHC.Int" +pREL_WORD_Name = mkModuleName "GHC.Word" fOREIGNOBJ_Name = mkModuleName "ForeignObj" aDDR_Name = mkModuleName "Addr" -pREL_GHC = mkPrelModule pREL_GHC_Name +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 @@ -245,6 +275,7 @@ 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} @@ -258,19 +289,19 @@ iNTERACTIVE = mkHomeModule (mkModuleName "$Interactive") \begin{code} 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 @@ -286,7 +317,7 @@ mkTupConRdrName space boxity arity = case mkTupNameStr boxity arity of \begin{code} main_RDR_Unqual :: RdrName -main_RDR_Unqual = mkUnqual varName SLIT("main") +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. @@ -304,208 +335,241 @@ compiler (notably the deriving mechanism) need to mention their names, and it's convenient to write them all down in one place. \begin{code} -mainName = varQual mAIN_Name SLIT("main") mainKey - --- Stuff from PrelGHC -usOnceTyConName = kindQual SLIT(".") usOnceTyConKey -usManyTyConName = kindQual SLIT("!") usManyTyConKey -superKindName = kindQual SLIT("KX") kindConKey -superBoxityName = kindQual SLIT("BX") boxityConKey -liftedConName = kindQual SLIT("*") liftedConKey -unliftedConName = kindQual SLIT("#") unliftedConKey -openKindConName = kindQual SLIT("?") anyBoxConKey -usageKindConName = kindQual SLIT("$") usageConKey -typeConName = kindQual SLIT("Type") typeConKey - -funTyConName = tcQual pREL_GHC_Name SLIT("(->)") funTyConKey -charPrimTyConName = tcQual pREL_GHC_Name SLIT("Char#") charPrimTyConKey -intPrimTyConName = tcQual pREL_GHC_Name SLIT("Int#") intPrimTyConKey -int32PrimTyConName = tcQual pREL_GHC_Name SLIT("Int32#") int32PrimTyConKey -int64PrimTyConName = tcQual pREL_GHC_Name SLIT("Int64#") int64PrimTyConKey -wordPrimTyConName = tcQual pREL_GHC_Name SLIT("Word#") wordPrimTyConKey -word32PrimTyConName = tcQual pREL_GHC_Name SLIT("Word32#") word32PrimTyConKey -word64PrimTyConName = tcQual pREL_GHC_Name SLIT("Word64#") word64PrimTyConKey -addrPrimTyConName = tcQual pREL_GHC_Name SLIT("Addr#") addrPrimTyConKey -floatPrimTyConName = tcQual pREL_GHC_Name SLIT("Float#") floatPrimTyConKey -doublePrimTyConName = tcQual pREL_GHC_Name SLIT("Double#") doublePrimTyConKey -statePrimTyConName = tcQual pREL_GHC_Name SLIT("State#") statePrimTyConKey -realWorldTyConName = tcQual pREL_GHC_Name SLIT("RealWorld") realWorldTyConKey -arrayPrimTyConName = tcQual pREL_GHC_Name SLIT("Array#") arrayPrimTyConKey -byteArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("ByteArray#") byteArrayPrimTyConKey -mutableArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("MutableArray#") mutableArrayPrimTyConKey -mutableByteArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("MutableByteArray#") mutableByteArrayPrimTyConKey -mutVarPrimTyConName = tcQual pREL_GHC_Name SLIT("MutVar#") mutVarPrimTyConKey -mVarPrimTyConName = tcQual pREL_GHC_Name SLIT("MVar#") mVarPrimTyConKey -stablePtrPrimTyConName = tcQual pREL_GHC_Name SLIT("StablePtr#") stablePtrPrimTyConKey -stableNamePrimTyConName = tcQual pREL_GHC_Name SLIT("StableName#") stableNamePrimTyConKey -foreignObjPrimTyConName = tcQual pREL_GHC_Name SLIT("ForeignObj#") foreignObjPrimTyConKey -bcoPrimTyConName = tcQual pREL_GHC_Name SLIT("BCO#") bcoPrimTyConKey -weakPrimTyConName = tcQual pREL_GHC_Name SLIT("Weak#") weakPrimTyConKey -threadIdPrimTyConName = tcQual pREL_GHC_Name SLIT("ThreadId#") threadIdPrimTyConKey -cCallableClassName = clsQual pREL_GHC_Name SLIT("CCallable") cCallableClassKey -cReturnableClassName = clsQual pREL_GHC_Name SLIT("CReturnable") cReturnableClassKey +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 -charTyConName = tcQual pREL_BASE_Name SLIT("Char") charTyConKey -charDataConName = dataQual pREL_BASE_Name SLIT("C#") charDataConKey -intTyConName = tcQual pREL_BASE_Name SLIT("Int") intTyConKey -intDataConName = dataQual pREL_BASE_Name SLIT("I#") intDataConKey -orderingTyConName = tcQual pREL_BASE_Name SLIT("Ordering") orderingTyConKey -boolTyConName = tcQual pREL_BASE_Name SLIT("Bool") boolTyConKey -falseDataConName = dataQual pREL_BASE_Name SLIT("False") falseDataConKey -trueDataConName = dataQual pREL_BASE_Name SLIT("True") trueDataConKey -listTyConName = tcQual pREL_BASE_Name SLIT("[]") listTyConKey -nilDataConName = dataQual pREL_BASE_Name SLIT("[]") nilDataConKey -consDataConName = dataQual pREL_BASE_Name SLIT(":") consDataConKey +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 -crossTyConName = tcQual pREL_BASE_Name SLIT(":*:") crossTyConKey -crossDataConName = dataQual pREL_BASE_Name SLIT(":*:") crossDataConKey -plusTyConName = tcQual pREL_BASE_Name SLIT(":+:") plusTyConKey -inlDataConName = dataQual pREL_BASE_Name SLIT("Inl") inlDataConKey -inrDataConName = dataQual pREL_BASE_Name SLIT("Inr") inrDataConKey -genUnitTyConName = tcQual pREL_BASE_Name SLIT("Unit") genUnitTyConKey -genUnitDataConName = dataQual pREL_BASE_Name SLIT("Unit") genUnitDataConKey +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 -unsafeCoerceName = varQual pREL_BASE_Name SLIT("unsafeCoerce") unsafeCoerceIdKey -otherwiseIdName = varQual pREL_BASE_Name SLIT("otherwise") otherwiseIdKey -appendName = varQual pREL_BASE_Name SLIT("++") appendIdKey -foldrName = varQual pREL_BASE_Name SLIT("foldr") foldrIdKey -mapName = varQual pREL_BASE_Name SLIT("map") mapIdKey -buildName = varQual pREL_BASE_Name SLIT("build") buildIdKey -augmentName = varQual pREL_BASE_Name SLIT("augment") augmentIdKey -eqStringName = varQual pREL_BASE_Name SLIT("eqString") eqStringIdKey +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 -unpackCStringName = varQual pREL_BASE_Name SLIT("unpackCString#") unpackCStringIdKey -unpackCStringListName = varQual pREL_BASE_Name SLIT("unpackCStringList#") unpackCStringListIdKey -unpackCStringAppendName = varQual pREL_BASE_Name SLIT("unpackAppendCString#") unpackCStringAppendIdKey -unpackCStringFoldrName = varQual pREL_BASE_Name SLIT("unpackFoldrCString#") unpackCStringFoldrIdKey -unpackCStringUtf8Name = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey +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 -eqClassName = clsQual pREL_BASE_Name SLIT("Eq") eqClassKey -ordClassName = clsQual pREL_BASE_Name SLIT("Ord") ordClassKey -eqName = varQual pREL_BASE_Name SLIT("==") eqClassOpKey -geName = varQual pREL_BASE_Name SLIT(">=") geClassOpKey +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 -monadClassName = clsQual pREL_BASE_Name SLIT("Monad") monadClassKey -monadPlusClassName = clsQual pREL_BASE_Name SLIT("MonadPlus") monadPlusClassKey -thenMName = varQual pREL_BASE_Name SLIT(">>=") thenMClassOpKey -returnMName = varQual pREL_BASE_Name SLIT("return") returnMClassOpKey -failMName = varQual pREL_BASE_Name SLIT("fail") failMClassOpKey +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 -functorClassName = clsQual pREL_BASE_Name SLIT("Functor") functorClassKey +functorClassName = clsQual pREL_BASE_Name FSLIT("Functor") functorClassKey -- Class Show -showClassName = clsQual pREL_SHOW_Name SLIT("Show") showClassKey +showClassName = clsQual pREL_SHOW_Name FSLIT("Show") showClassKey -- Class Read -readClassName = clsQual pREL_READ_Name SLIT("Read") readClassKey +readClassName = clsQual pREL_READ_Name FSLIT("Read") readClassKey -- Module PrelNum -numClassName = clsQual pREL_NUM_Name SLIT("Num") numClassKey -fromIntegerName = varQual pREL_NUM_Name SLIT("fromInteger") fromIntegerClassOpKey -minusName = varQual pREL_NUM_Name SLIT("-") minusClassOpKey -negateName = varQual pREL_NUM_Name SLIT("negate") negateClassOpKey -plusIntegerName = varQual pREL_NUM_Name SLIT("plusInteger") plusIntegerIdKey -timesIntegerName = varQual pREL_NUM_Name SLIT("timesInteger") timesIntegerIdKey -integerTyConName = tcQual pREL_NUM_Name SLIT("Integer") integerTyConKey -smallIntegerDataConName = dataQual pREL_NUM_Name SLIT("S#") smallIntegerDataConKey -largeIntegerDataConName = dataQual pREL_NUM_Name SLIT("J#") largeIntegerDataConKey +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 -rationalTyConName = tcQual pREL_REAL_Name SLIT("Rational") rationalTyConKey -ratioTyConName = tcQual pREL_REAL_Name SLIT("Ratio") ratioTyConKey -ratioDataConName = dataQual pREL_REAL_Name SLIT(":%") ratioDataConKey -realClassName = clsQual pREL_REAL_Name SLIT("Real") realClassKey -integralClassName = clsQual pREL_REAL_Name SLIT("Integral") integralClassKey -realFracClassName = clsQual pREL_REAL_Name SLIT("RealFrac") realFracClassKey -fractionalClassName = clsQual pREL_REAL_Name SLIT("Fractional") fractionalClassKey -fromRationalName = varQual pREL_REAL_Name SLIT("fromRational") fromRationalClassOpKey +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 -floatTyConName = tcQual pREL_FLOAT_Name SLIT("Float") floatTyConKey -floatDataConName = dataQual pREL_FLOAT_Name SLIT("F#") floatDataConKey -doubleTyConName = tcQual pREL_FLOAT_Name SLIT("Double") doubleTyConKey -doubleDataConName = dataQual pREL_FLOAT_Name SLIT("D#") doubleDataConKey -floatingClassName = clsQual pREL_FLOAT_Name SLIT("Floating") floatingClassKey -realFloatClassName = clsQual pREL_FLOAT_Name SLIT("RealFloat") realFloatClassKey +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 -ixClassName = clsQual pREL_ARR_Name SLIT("Ix") ixClassKey +ixClassName = clsQual pREL_ARR_Name FSLIT("Ix") ixClassKey -- Class Enum -enumClassName = clsQual pREL_ENUM_Name SLIT("Enum") enumClassKey -toEnumName = varQual pREL_ENUM_Name SLIT("toEnum") toEnumClassOpKey -fromEnumName = varQual pREL_ENUM_Name SLIT("fromEnum") fromEnumClassOpKey -enumFromName = varQual pREL_ENUM_Name SLIT("enumFrom") enumFromClassOpKey -enumFromToName = varQual pREL_ENUM_Name SLIT("enumFromTo") enumFromToClassOpKey -enumFromThenName = varQual pREL_ENUM_Name SLIT("enumFromThen") enumFromThenClassOpKey -enumFromThenToName = varQual pREL_ENUM_Name SLIT("enumFromThenTo") enumFromThenToClassOpKey +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 -boundedClassName = clsQual pREL_ENUM_Name SLIT("Bounded") boundedClassKey +boundedClassName = clsQual pREL_ENUM_Name FSLIT("Bounded") boundedClassKey -- List functions -concatName = varQual pREL_LIST_Name SLIT("concat") concatIdKey -filterName = varQual pREL_LIST_Name SLIT("filter") filterIdKey -zipName = varQual pREL_LIST_Name SLIT("zip") zipIdKey +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 -ioTyConName = tcQual pREL_IO_BASE_Name SLIT("IO") ioTyConKey -ioDataConName = dataQual pREL_IO_BASE_Name SLIT("IO") ioDataConKey -bindIOName = varQual pREL_IO_BASE_Name SLIT("bindIO") bindIOIdKey -returnIOName = varQual pREL_IO_BASE_Name SLIT("returnIO") returnIOIdKey -failIOName = varQual pREL_IO_BASE_Name SLIT("failIO") failIOIdKey +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 pREL_IO_Name SLIT("print") printIdKey +printName = varQual sYSTEM_IO_Name FSLIT("print") printIdKey -- Int, Word, and Addr things -int8TyConName = tcQual pREL_INT_Name SLIT("Int8") int8TyConKey -int16TyConName = tcQual pREL_INT_Name SLIT("Int16") int16TyConKey -int32TyConName = tcQual pREL_INT_Name SLIT("Int32") int32TyConKey -int64TyConName = tcQual pREL_INT_Name SLIT("Int64") int64TyConKey +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 -word8TyConName = tcQual pREL_WORD_Name SLIT("Word8") word8TyConKey -word16TyConName = tcQual pREL_WORD_Name SLIT("Word16") word16TyConKey -word32TyConName = tcQual pREL_WORD_Name SLIT("Word32") word32TyConKey -word64TyConName = tcQual pREL_WORD_Name SLIT("Word64") word64TyConKey +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 -wordTyConName = tcQual pREL_WORD_Name SLIT("Word") wordTyConKey -wordDataConName = dataQual pREL_WORD_Name SLIT("W#") wordDataConKey +wordTyConName = tcQual pREL_WORD_Name FSLIT("Word") wordTyConKey +wordDataConName = dataQual pREL_WORD_Name FSLIT("W#") wordDataConKey -addrTyConName = tcQual aDDR_Name SLIT("Addr") addrTyConKey -addrDataConName = dataQual aDDR_Name SLIT("A#") addrDataConKey +addrTyConName = tcQual aDDR_Name FSLIT("Addr") addrTyConKey +addrDataConName = dataQual aDDR_Name FSLIT("A#") addrDataConKey -ptrTyConName = tcQual pREL_PTR_Name SLIT("Ptr") ptrTyConKey -ptrDataConName = dataQual pREL_PTR_Name SLIT("Ptr") ptrDataConKey +ptrTyConName = tcQual pREL_PTR_Name FSLIT("Ptr") ptrTyConKey +ptrDataConName = dataQual pREL_PTR_Name FSLIT("Ptr") ptrDataConKey -funPtrTyConName = tcQual pREL_PTR_Name SLIT("FunPtr") funPtrTyConKey -funPtrDataConName = dataQual pREL_PTR_Name SLIT("FunPtr") funPtrDataConKey +funPtrTyConName = tcQual pREL_PTR_Name FSLIT("FunPtr") funPtrTyConKey +funPtrDataConName = dataQual pREL_PTR_Name FSLIT("FunPtr") funPtrDataConKey -- Byte array types -byteArrayTyConName = tcQual pREL_BYTEARR_Name SLIT("ByteArray") byteArrayTyConKey -mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name SLIT("MutableByteArray") mutableByteArrayTyConKey - --- Forign objects and weak pointers -foreignObjTyConName = tcQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjTyConKey -foreignObjDataConName = dataQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjDataConKey -foreignPtrTyConName = tcQual pREL_FOREIGN_Name SLIT("ForeignPtr") foreignPtrTyConKey -foreignPtrDataConName = dataQual pREL_FOREIGN_Name SLIT("ForeignPtr") foreignPtrDataConKey -stablePtrTyConName = tcQual pREL_STABLE_Name SLIT("StablePtr") stablePtrTyConKey -stablePtrDataConName = dataQual pREL_STABLE_Name SLIT("StablePtr") stablePtrDataConKey -deRefStablePtrName = varQual pREL_STABLE_Name SLIT("deRefStablePtr") deRefStablePtrIdKey -newStablePtrName = varQual pREL_STABLE_Name SLIT("newStablePtr") newStablePtrIdKey - -errorName = varQual pREL_ERR_Name SLIT("error") errorIdKey -assertName = varQual pREL_GHC_Name SLIT("assert") assertIdKey -getTagName = varQual pREL_GHC_Name SLIT("getTag#") getTagIdKey -runSTRepName = varQual pREL_ST_Name SLIT("runSTRep") runSTRepIdKey +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} %************************************************************************ @@ -530,44 +594,62 @@ tupleTyCon_RDR = mkTupConRdrName tcName Boxed ubxTupleCon_RDR = mkTupConRdrName dataName Unboxed ubxTupleTyCon_RDR = mkTupConRdrName tcName Unboxed -unitCon_RDR = dataQual_RDR pREL_BASE_Name SLIT("()") -unitTyCon_RDR = tcQual_RDR pREL_BASE_Name SLIT("()") - -and_RDR = varQual_RDR pREL_BASE_Name SLIT("&&") -not_RDR = varQual_RDR pREL_BASE_Name SLIT("not") -compose_RDR = varQual_RDR pREL_BASE_Name SLIT(".") -ne_RDR = varQual_RDR pREL_BASE_Name SLIT("/=") -le_RDR = varQual_RDR pREL_BASE_Name SLIT("<=") -lt_RDR = varQual_RDR pREL_BASE_Name SLIT("<") -gt_RDR = varQual_RDR pREL_BASE_Name SLIT(">") -ltTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("LT") -eqTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("EQ") -gtTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("GT") -max_RDR = varQual_RDR pREL_BASE_Name SLIT("max") -min_RDR = varQual_RDR pREL_BASE_Name SLIT("min") -compare_RDR = varQual_RDR pREL_BASE_Name SLIT("compare") -showList_RDR = varQual_RDR pREL_SHOW_Name SLIT("showList") -showList___RDR = varQual_RDR pREL_SHOW_Name SLIT("showList__") -showsPrec_RDR = varQual_RDR pREL_SHOW_Name SLIT("showsPrec") -showSpace_RDR = varQual_RDR pREL_SHOW_Name SLIT("showSpace") -showString_RDR = varQual_RDR pREL_SHOW_Name SLIT("showString") -showParen_RDR = varQual_RDR pREL_SHOW_Name SLIT("showParen") -readsPrec_RDR = varQual_RDR pREL_READ_Name SLIT("readsPrec") -readList_RDR = varQual_RDR pREL_READ_Name SLIT("readList") -readParen_RDR = varQual_RDR pREL_READ_Name SLIT("readParen") -lex_RDR = varQual_RDR pREL_READ_Name SLIT("lex") -readList___RDR = varQual_RDR pREL_READ_Name SLIT("readList__") -times_RDR = varQual_RDR pREL_NUM_Name SLIT("*") -plus_RDR = varQual_RDR pREL_NUM_Name SLIT("+") -negate_RDR = varQual_RDR pREL_NUM_Name SLIT("negate") -range_RDR = varQual_RDR pREL_ARR_Name SLIT("range") -index_RDR = varQual_RDR pREL_ARR_Name SLIT("index") -inRange_RDR = varQual_RDR pREL_ARR_Name SLIT("inRange") -succ_RDR = varQual_RDR pREL_ENUM_Name SLIT("succ") -pred_RDR = varQual_RDR pREL_ENUM_Name SLIT("pred") -minBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("minBound") -maxBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("maxBound") -assertErr_RDR = varQual_RDR pREL_ERR_Name SLIT("assertError") +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 @@ -577,6 +659,7 @@ populate the occurrence list above. 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 @@ -589,7 +672,7 @@ foldr_RDR = nameRdrName foldrName build_RDR = nameRdrName buildName enumFromTo_RDR = nameRdrName enumFromToName returnM_RDR = nameRdrName returnMName -thenM_RDR = nameRdrName thenMName +bindM_RDR = nameRdrName bindMName failM_RDR = nameRdrName failMName false_RDR = nameRdrName falseDataConName true_RDR = nameRdrName trueDataConName @@ -632,12 +715,12 @@ minus_RDR = nameRdrName minusName All these are original names; hence mkOrig \begin{code} -varQual mod str uq = mkKnownKeyGlobal (varQual_RDR mod str) uq -dataQual mod str uq = mkKnownKeyGlobal (dataQual_RDR mod str) uq -tcQual mod str uq = mkKnownKeyGlobal (tcQual_RDR mod str) uq -clsQual mod str uq = mkKnownKeyGlobal (clsQual_RDR mod str) uq +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 = mkLocalName uq (mkKindOccFS tcName str) builtinSrcLoc +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 @@ -662,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 @@ -671,7 +753,7 @@ realClassKey = mkPreludeClassUnique 14 realFloatClassKey = mkPreludeClassUnique 15 realFracClassKey = mkPreludeClassUnique 16 showClassKey = mkPreludeClassUnique 17 - + cCallableClassKey = mkPreludeClassUnique 18 cReturnableClassKey = mkPreludeClassUnique 19 @@ -756,6 +838,9 @@ crossTyConKey = mkPreludeTyConUnique 79 plusTyConKey = mkPreludeTyConUnique 80 genUnitTyConKey = mkPreludeTyConUnique 81 +-- Parallel array type constructor +parrTyConKey = mkPreludeTyConUnique 82 + unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} @@ -792,6 +877,9 @@ crossDataConKey = mkPreludeDataConUnique 20 inlDataConKey = mkPreludeDataConUnique 21 inrDataConKey = mkPreludeDataConUnique 22 genUnitDataConKey = mkPreludeDataConUnique 23 + +-- Data constructor for parallel arrays +parrDataConKey = mkPreludeDataConUnique 24 \end{code} %************************************************************************ @@ -819,7 +907,7 @@ irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15 eqStringIdKey = mkPreludeMiscIdUnique 16 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18 -errorCStringIdKey = mkPreludeMiscIdUnique 19 +runtimeErrorIdKey = mkPreludeMiscIdUnique 19 parErrorIdKey = mkPreludeMiscIdUnique 20 parIdKey = mkPreludeMiscIdUnique 21 patErrorIdKey = mkPreludeMiscIdUnique 22 @@ -845,9 +933,38 @@ plusIntegerIdKey = mkPreludeMiscIdUnique 41 timesIntegerIdKey = mkPreludeMiscIdUnique 42 printIdKey = mkPreludeMiscIdUnique 43 failIOIdKey = mkPreludeMiscIdUnique 44 -unpackCStringListIdKey = mkPreludeMiscIdUnique 45 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 @@ -855,6 +972,8 @@ uniques so we can look them up easily when we want to conjure them up during type checking. \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 @@ -866,21 +985,11 @@ 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} @@ -950,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])