)
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}
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
knownKeyNames
= [
-- Type constructors (synonyms especially)
- ioTyConName,
- mainName,
+ ioTyConName, ioDataConName,
+ runMainName,
orderingTyConName,
rationalTyConName,
ratioDataConName,
numClassName, -- mentioned, numeric
enumClassName, -- derivable
monadClassName,
- monadPlusClassName,
functorClassName,
showClassName, -- derivable
realClassName, -- numeric
toEnumName,
eqName,
thenMName,
+ bindMName,
returnMName,
failMName,
fromRationalName,
-
+
+ -- not class methods, but overloaded (for parallel arrays)
+ enumFromToPName,
+ enumFromThenToPName,
+
deRefStablePtrName,
newStablePtrName,
bindIOName,
+ thenIOName,
returnIOName,
failIOName,
mapName,
appendName,
unpackCStringName,
- unpackCStringListName,
unpackCStringAppendName,
unpackCStringFoldrName,
unpackCStringUtf8Name,
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,
eqStringName,
assertName,
runSTRepName,
- printName
+ printName,
+ splitName, fstName, sndName, -- Used by splittery
+
+ -- Others (needed for flattening and not mentioned before)
+ andName,
+ orName
]
\end{code}
\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
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}
\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
\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.
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}
%************************************************************************
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")
+punc_RDR = dataQual_RDR lEX_Name FSLIT("Punc")
+
+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
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
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
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
fractionalClassKey = mkPreludeClassUnique 6
integralClassKey = mkPreludeClassUnique 7
monadClassKey = mkPreludeClassUnique 8
-monadPlusClassKey = mkPreludeClassUnique 9
functorClassKey = mkPreludeClassUnique 10
numClassKey = mkPreludeClassUnique 11
ordClassKey = mkPreludeClassUnique 12
realFloatClassKey = mkPreludeClassUnique 15
realFracClassKey = mkPreludeClassUnique 16
showClassKey = mkPreludeClassUnique 17
-
+
cCallableClassKey = mkPreludeClassUnique 18
cReturnableClassKey = mkPreludeClassUnique 19
plusTyConKey = mkPreludeTyConUnique 80
genUnitTyConKey = mkPreludeTyConUnique 81
+-- Parallel array type constructor
+parrTyConKey = mkPreludeTyConUnique 82
+
unitTyConKey = mkTupleTyConUnique Boxed 0
\end{code}
inlDataConKey = mkPreludeDataConUnique 21
inrDataConKey = mkPreludeDataConUnique 22
genUnitDataConKey = mkPreludeDataConUnique 23
+
+-- Data constructor for parallel arrays
+parrDataConKey = mkPreludeDataConUnique 24
\end{code}
%************************************************************************
eqStringIdKey = mkPreludeMiscIdUnique 16
noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17
nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
-errorCStringIdKey = mkPreludeMiscIdUnique 19
+runtimeErrorIdKey = mkPreludeMiscIdUnique 19
parErrorIdKey = mkPreludeMiscIdUnique 20
parIdKey = mkPreludeMiscIdUnique 21
patErrorIdKey = mkPreludeMiscIdUnique 22
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
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
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}
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])
projects / ghc-hetmet.git / blobdiff