X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FPrelNames.lhs;h=947febac6405be25ccb1dfefbfc18d4cb5487c65;hb=1f5e55804b97d2b9a77207d568d602ba88d8855d;hp=fd5e769f8a0378159de260fa16e3a6455ee98216;hpb=4e5a383f739c312e3811b89d519a95a675182e58;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/PrelNames.lhs b/ghc/compiler/prelude/PrelNames.lhs index fd5e769..947feba 100644 --- a/ghc/compiler/prelude/PrelNames.lhs +++ b/ghc/compiler/prelude/PrelNames.lhs @@ -4,15 +4,7 @@ \section[PrelNames]{Definitions of prelude modules and names} --- MetaHaskell Extension -to do -- three things -1) Allocate a key -2) Make a "Name" -3) Add the name to knownKeyNames - - -The strings identify built-in prelude modules. They are -defined here so as to avod +Nota Bene: all Names defined in here should come from the base package * ModuleNames for prelude modules, e.g. pREL_BASE_Name :: ModuleName @@ -50,36 +42,16 @@ module PrelNames ( ----------------------------------------------------------- module PrelNames, -- A huge bunch of (a) Names, e.g. intTyConName -- (b) Uniques e.g. intTyConKey + -- (c) Groups of classes and types + -- (d) miscellaneous things -- So many that we export them all - - ----------------------------------------------------------- - knownKeyNames, templateHaskellNames, - mkTupNameStr, isBuiltInSyntaxName, - - ------------------------------------------------------------ - -- Goups of classes and types - needsDataDeclCtxtClassKeys, cCallishClassKeys, noDictClassKeys, - fractionalClassKeys, numericClassKeys, standardClassKeys, - derivableClassKeys, -- things are needed as a result of a - -- deriving(C) clause - numericTyKeys, cCallishTyKeys, - - mkUnboundName, isUnboundName ) where #include "HsVersions.h" -import Module ( ModuleName, mkPrelModule, mkHomeModule, mkModuleName,mkVanillaModule ) -import OccName ( UserFS, dataName, tcName, clsName, - mkKindOccFS, mkOccFS +import Module ( Module, mkBasePkgModule, mkHomeModule, mkModuleName ) +import OccName ( dataName, tcName, clsName, varName, mkOccFS ) - --- to avoid clashes with Meta.var we must make a local alias for OccName.varName --- we do this by removing varName from the import of OccName above, making --- a qualified instance of OccName and using OccNameAlias.varName where varName --- ws previously used in this file. -import qualified OccName as OccNameAlias - import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc ) import Unique ( Unique, Uniquable(..), hasKey, @@ -87,12 +59,9 @@ import Unique ( Unique, Uniquable(..), hasKey, mkPreludeTyConUnique, mkPreludeClassUnique, mkTupleTyConUnique, isTupleKey ) -import BasicTypes ( Boxity(..) ) -import Name ( Name, mkInternalName, mkKnownKeyExternalName, mkWiredInName, nameUnique ) -import NameSet ( NameSet, mkNameSet ) +import BasicTypes ( Boxity(..), Arity ) +import Name ( Name, mkInternalName, mkExternalName, nameUnique, nameModule ) import SrcLoc ( noSrcLoc ) -import Util ( nOfThem ) -import Panic ( panic ) import FastString @@ -108,7 +77,7 @@ import FastString This *local* name is used by the interactive stuff \begin{code} -itName uniq = mkInternalName uniq (mkOccFS OccNameAlias.varName FSLIT("it")) noSrcLoc +itName uniq = mkInternalName uniq (mkOccFS varName FSLIT("it")) noSrcLoc \end{code} \begin{code} @@ -151,13 +120,12 @@ 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. - -MetaHaskell Extension -It is here that the names defiend in module Meta must be added \begin{code} -knownKeyNames :: [Name] -knownKeyNames - = [ -- Type constructors (synonyms especially) +basicKnownKeyNames :: [Name] +basicKnownKeyNames + = genericTyConNames + ++ monadNames + ++ [ -- Type constructors (synonyms especially) ioTyConName, ioDataConName, runIOName, orderingTyConName, @@ -166,9 +134,7 @@ knownKeyNames ratioTyConName, byteArrayTyConName, mutableByteArrayTyConName, - bcoPrimTyConName, - stablePtrTyConName, - stablePtrDataConName, + integerTyConName, smallIntegerDataConName, largeIntegerDataConName, -- Classes. *Must* include: -- classes that are grabbed by key (e.g., eqClassKey) @@ -186,8 +152,8 @@ knownKeyNames floatingClassName, -- numeric realFracClassName, -- numeric realFloatClassName, -- numeric - cCallableClassName, -- mentioned, ccallish - cReturnableClassName, -- mentioned, ccallish + dataClassName, + typeableClassName, -- Numeric stuff negateName, minusName, @@ -200,9 +166,15 @@ knownKeyNames enumFromToPName, enumFromThenToPName, -- Monad stuff - thenMName, bindMName, returnMName, failMName, thenIOName, bindIOName, returnIOName, failIOName, + -- MonadRec stuff + mfixName, + + -- Arrow stuff + arrAName, composeAName, firstAName, + appAName, choiceAName, loopAName, + -- Ix stuff ixClassName, @@ -228,70 +200,33 @@ knownKeyNames filterPName, zipPName, crossPName, indexPName, toPName, bpermutePName, bpermuteDftPName, indexOfPName, - -- MetaHaskell Extension, "the smart constructors" - -- text1 from Meta/work/gen.hs - intLName, - charLName, - plitName, - pvarName, - ptupName, - pconName, - ptildeName, - paspatName, - pwildName, - varName, - conName, - litName, - appName, - infixEName, - lamName, - tupName, - doEName, - compName, - listExpName, - condName, - letEName, - caseEName, - infixAppName, - sectionLName, - sectionRName, - guardedName, - normalName, - bindStName, - letStName, - noBindStName, - parStName, - fromName, - fromThenName, - fromToName, - fromThenToName, - liftName, - gensymName, - returnQName, - bindQName, - funName, - valName, - protoName, matchName, clauseName, - exprTyConName, declTyConName, pattTyConName, mtchTyConName, clseTyConName, - qTyConName, expTyConName, matTyConName, clsTyConName, - -- FFI primitive types that are not wired-in. + stablePtrTyConName, ptrTyConName, funPtrTyConName, addrTyConName, int8TyConName, int16TyConName, int32TyConName, int64TyConName, - word8TyConName, word16TyConName, word32TyConName, word64TyConName, + wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName, -- Others - unsafeCoerceName, otherwiseIdName, + otherwiseIdName, plusIntegerName, timesIntegerName, - eqStringName, assertName, assertErrorName, runSTRepName, + eqStringName, assertName, runSTRepName, printName, splitName, fstName, sndName, - errorName, -- Booleans andName, orName + + -- The Either type + , eitherTyConName, leftDataConName, rightDataConName + + -- dotnet interop + , objectTyConName, marshalObjectName, unmarshalObjectName + , marshalStringName, unmarshalStringName, checkDotnetResName ] monadNames :: [Name] -- The monad ops need by a HsDo monadNames = [returnMName, failMName, bindMName, thenMName] + +genericTyConNames :: [Name] +genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName] \end{code} @@ -314,6 +249,7 @@ 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_EITHER_Name = mkModuleName "Data.Either" pREL_PACK_Name = mkModuleName "GHC.Pack" pREL_CONC_Name = mkModuleName "GHC.Conc" pREL_IO_BASE_Name = mkModuleName "GHC.IOBase" @@ -328,6 +264,10 @@ 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" +dYNAMIC_Name = mkModuleName "Data.Dynamic" +tYPEABLE_Name = mkModuleName "Data.Typeable" +gENERICS_Name = mkModuleName "Data.Generics.Basics" +dOTNET_Name = mkModuleName "GHC.Dotnet" rEAD_PREC_Name = mkModuleName "Text.ParserCombinators.ReadPrec" lEX_Name = mkModuleName "Text.Read.Lex" @@ -335,29 +275,53 @@ lEX_Name = mkModuleName "Text.Read.Lex" mAIN_Name = mkModuleName "Main" pREL_INT_Name = mkModuleName "GHC.Int" pREL_WORD_Name = mkModuleName "GHC.Word" - +mONAD_FIX_Name = mkModuleName "Control.Monad.Fix" +aRROW_Name = mkModuleName "Control.Arrow" 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") - --- MetaHaskell Extension text2 from Meta/work/gen.hs -mETA_META_Name = mkModuleName "Language.Haskell.THSyntax" - +gHC_PRIM = mkBasePkgModule gHC_PRIM_Name +pREL_BASE = mkBasePkgModule pREL_BASE_Name +pREL_TUP = mkBasePkgModule pREL_TUP_Name +pREL_EITHER = mkBasePkgModule pREL_EITHER_Name +pREL_LIST = mkBasePkgModule pREL_LIST_Name +pREL_SHOW = mkBasePkgModule pREL_SHOW_Name +pREL_READ = mkBasePkgModule pREL_READ_Name +pREL_ADDR = mkBasePkgModule pREL_ADDR_Name +pREL_WORD = mkBasePkgModule pREL_WORD_Name +pREL_INT = mkBasePkgModule pREL_INT_Name +pREL_PTR = mkBasePkgModule pREL_PTR_Name +pREL_ST = mkBasePkgModule pREL_ST_Name +pREL_STABLE = mkBasePkgModule pREL_STABLE_Name +pREL_IO_BASE = mkBasePkgModule pREL_IO_BASE_Name +pREL_PACK = mkBasePkgModule pREL_PACK_Name +pREL_ERR = mkBasePkgModule pREL_ERR_Name +pREL_NUM = mkBasePkgModule pREL_NUM_Name +pREL_ENUM = mkBasePkgModule pREL_ENUM_Name +pREL_REAL = mkBasePkgModule pREL_REAL_Name +pREL_FLOAT = mkBasePkgModule pREL_FLOAT_Name +pREL_ARR = mkBasePkgModule pREL_ARR_Name +pREL_PARR = mkBasePkgModule pREL_PARR_Name +pREL_BYTEARR = mkBasePkgModule pREL_BYTEARR_Name +pREL_TOP_HANDLER= mkBasePkgModule pREL_TOP_HANDLER_Name +pRELUDE = mkBasePkgModule pRELUDE_Name +sYSTEM_IO = mkBasePkgModule sYSTEM_IO_Name +aDDR = mkBasePkgModule aDDR_Name +aRROW = mkBasePkgModule aRROW_Name +gENERICS = mkBasePkgModule gENERICS_Name +tYPEABLE = mkBasePkgModule tYPEABLE_Name +dOTNET = mkBasePkgModule dOTNET_Name +gLA_EXTS = mkBasePkgModule gLA_EXTS_Name +mONAD_FIX = mkBasePkgModule mONAD_FIX_Name + +rOOT_MAIN_Name = mkModuleName ":Main" -- Root module for initialisation +rOOT_MAIN = mkHomeModule rOOT_MAIN_Name + -- The ':xxx' makes a moudle name that the user can never + -- use himself. The z-encoding for ':' is "ZC", so the z-encoded + -- module name still starts with a capital letter, which keeps + -- the z-encoded version consistent. +iNTERACTIVE = mkHomeModule (mkModuleName ":Interactive") \end{code} %************************************************************************ @@ -367,21 +331,10 @@ mETA_META_Name = mkModuleName "Language.Haskell.THSyntax" %************************************************************************ \begin{code} -mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS) - -mkTupNameStr Boxed 0 = (pREL_BASE_Name, FSLIT("()")) -mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 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 = (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) ',' ++ "#)")) +mkTupleModule :: Boxity -> Arity -> Module +mkTupleModule Boxed 0 = pREL_BASE +mkTupleModule Boxed _ = pREL_TUP +mkTupleModule Unboxed _ = gHC_PRIM \end{code} @@ -392,8 +345,6 @@ mkTupNameStr Unboxed n = (gHC_PRIM_Name, mkFastString ("(#" ++ nOfThem (n-1) ',' %************************************************************************ \begin{code} -getTag_RDR = nameRdrName getTagName - eq_RDR = nameRdrName eqName ge_RDR = nameRdrName geName ne_RDR = varQual_RDR pREL_BASE_Name FSLIT("/=") @@ -409,8 +360,6 @@ numClass_RDR = nameRdrName numClassName ordClass_RDR = nameRdrName ordClassName enumClass_RDR = nameRdrName enumClassName monadClass_RDR = nameRdrName monadClassName -cCallableClass_RDR = nameRdrName cCallableClassName -cReturnableClass_RDR = nameRdrName cReturnableClassName map_RDR = varQual_RDR pREL_BASE_Name FSLIT("map") append_RDR = varQual_RDR pREL_BASE_Name FSLIT("++") @@ -421,15 +370,13 @@ returnM_RDR = nameRdrName returnMName bindM_RDR = nameRdrName bindMName failM_RDR = nameRdrName failMName -false_RDR = nameRdrName falseDataConName -true_RDR = nameRdrName trueDataConName and_RDR = nameRdrName andName -error_RDR = nameRdrName errorName +left_RDR = nameRdrName leftDataConName +right_RDR = nameRdrName rightDataConName fromEnum_RDR = varQual_RDR pREL_ENUM_Name FSLIT("fromEnum") toEnum_RDR = varQual_RDR pREL_ENUM_Name FSLIT("toEnum") -mkInt_RDR = nameRdrName intDataConName enumFrom_RDR = nameRdrName enumFromName enumFromTo_RDR = nameRdrName enumFromToName @@ -448,6 +395,8 @@ unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name newStablePtr_RDR = nameRdrName newStablePtrName +addrDataCon_RDR = dataQual_RDR aDDR_Name FSLIT("A#") +wordDataCon_RDR = dataQual_RDR pREL_WORD_Name FSLIT("W#") bindIO_RDR = nameRdrName bindIOName returnIO_RDR = nameRdrName returnIOName @@ -461,6 +410,7 @@ plus_RDR = varQual_RDR pREL_NUM_Name FSLIT("+") compose_RDR = varQual_RDR pREL_BASE_Name FSLIT(".") not_RDR = varQual_RDR pREL_BASE_Name FSLIT("not") +getTag_RDR = varQual_RDR pREL_BASE_Name FSLIT("getTag") 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") @@ -493,8 +443,24 @@ showsPrec_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showsPrec") showString_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showString") showSpace_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showSpace") showParen_RDR = varQual_RDR pREL_SHOW_Name FSLIT("showParen") -\end{code} +typeOf_RDR = varQual_RDR tYPEABLE_Name FSLIT("typeOf") +mkTypeRep_RDR = varQual_RDR tYPEABLE_Name FSLIT("mkAppTy") +mkTyConRep_RDR = varQual_RDR tYPEABLE_Name FSLIT("mkTyCon") + +undefined_RDR = varQual_RDR pREL_ERR_Name FSLIT("undefined") + +crossDataCon_RDR = dataQual_RDR pREL_BASE_Name FSLIT(":*:") +inlDataCon_RDR = dataQual_RDR pREL_BASE_Name FSLIT("Inl") +inrDataCon_RDR = dataQual_RDR pREL_BASE_Name FSLIT("Inr") +genUnitDataCon_RDR = dataQual_RDR pREL_BASE_Name FSLIT("Unit") + +---------------------- +varQual_RDR mod str = mkOrig mod (mkOccFS varName str) +tcQual_RDR mod str = mkOrig mod (mkOccFS tcName str) +clsQual_RDR mod str = mkOrig mod (mkOccFS clsName str) +dataQual_RDR mod str = mkOrig mod (mkOccFS dataName str) +\end{code} %************************************************************************ %* * @@ -511,324 +477,191 @@ and it's convenient to write them all down in one place. \begin{code} -dollarMainName = varQual mAIN_Name FSLIT("$main") dollarMainKey -runIOName = varQual pREL_TOP_HANDLER_Name FSLIT("runIO") 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 - -getTagName = wVarQual gHC_PRIM_Name FSLIT("getTag#") getTagIdKey -unsafeCoerceName = wVarQual gHC_PRIM_Name FSLIT("unsafeCoerce#") unsafeCoerceIdKey -nullAddrName = wVarQual gHC_PRIM_Name FSLIT("nullAddr#") nullAddrIdKey -seqName = wVarQual gHC_PRIM_Name FSLIT("seq") seqIdKey -realWorldName = wVarQual gHC_PRIM_Name FSLIT("realWorld#") realWorldPrimIdKey - --- PrelBase data types and constructors -charTyConName = wTcQual pREL_BASE_Name FSLIT("Char") charTyConKey -charDataConName = wDataQual pREL_BASE_Name FSLIT("C#") charDataConKey -intTyConName = wTcQual pREL_BASE_Name FSLIT("Int") intTyConKey -intDataConName = wDataQual pREL_BASE_Name FSLIT("I#") intDataConKey -orderingTyConName = tcQual pREL_BASE_Name FSLIT("Ordering") orderingTyConKey -boolTyConName = wTcQual pREL_BASE_Name FSLIT("Bool") boolTyConKey -falseDataConName = wDataQual pREL_BASE_Name FSLIT("False") falseDataConKey -trueDataConName = wDataQual pREL_BASE_Name FSLIT("True") trueDataConKey -listTyConName = wTcQual pREL_BASE_Name FSLIT("[]") listTyConKey -nilDataConName = wDataQual pREL_BASE_Name FSLIT("[]") nilDataConKey -consDataConName = wDataQual pREL_BASE_Name FSLIT(":") consDataConKey -eqName = varQual pREL_BASE_Name FSLIT("==") eqClassOpKey -geName = varQual pREL_BASE_Name FSLIT(">=") geClassOpKey +rootMainName = varQual rOOT_MAIN FSLIT("main") rootMainKey +runIOName = varQual pREL_TOP_HANDLER FSLIT("runIO") runMainKey + +orderingTyConName = tcQual pREL_BASE FSLIT("Ordering") orderingTyConKey + +eitherTyConName = tcQual pREL_EITHER FSLIT("Either") eitherTyConKey +leftDataConName = conName eitherTyConName FSLIT("Left") leftDataConKey +rightDataConName = conName eitherTyConName FSLIT("Right") rightDataConKey -- Generics -crossTyConName = tcQual pREL_BASE_Name FSLIT(":*:") crossTyConKey -crossDataConName = dataQual pREL_BASE_Name FSLIT(":*:") crossDataConKey -plusTyConName = wTcQual pREL_BASE_Name FSLIT(":+:") plusTyConKey -inlDataConName = wDataQual pREL_BASE_Name FSLIT("Inl") inlDataConKey -inrDataConName = wDataQual pREL_BASE_Name FSLIT("Inr") inrDataConKey -genUnitTyConName = wTcQual pREL_BASE_Name FSLIT("Unit") genUnitTyConKey -genUnitDataConName = wDataQual pREL_BASE_Name FSLIT("Unit") genUnitDataConKey +crossTyConName = tcQual pREL_BASE FSLIT(":*:") crossTyConKey +plusTyConName = tcQual pREL_BASE FSLIT(":+:") plusTyConKey +genUnitTyConName = tcQual pREL_BASE FSLIT("Unit") genUnitTyConKey -- Base strings Strings -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 -eqStringName = varQual pREL_BASE_Name FSLIT("eqString") eqStringIdKey +unpackCStringName = varQual pREL_BASE FSLIT("unpackCString#") unpackCStringIdKey +unpackCStringAppendName = varQual pREL_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey +unpackCStringFoldrName = varQual pREL_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey +unpackCStringUtf8Name = varQual pREL_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey +eqStringName = varQual pREL_BASE FSLIT("eqString") eqStringIdKey -- Base classes (Eq, Ord, Functor) -eqClassName = clsQual pREL_BASE_Name FSLIT("Eq") eqClassKey -functorClassName = clsQual pREL_BASE_Name FSLIT("Functor") functorClassKey -ordClassName = clsQual pREL_BASE_Name FSLIT("Ord") ordClassKey +eqClassName = clsQual pREL_BASE FSLIT("Eq") eqClassKey +eqName = methName eqClassName FSLIT("==") eqClassOpKey +ordClassName = clsQual pREL_BASE FSLIT("Ord") ordClassKey +geName = methName ordClassName FSLIT(">=") geClassOpKey +functorClassName = clsQual pREL_BASE FSLIT("Functor") functorClassKey -- Class Monad -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 - +monadClassName = clsQual pREL_BASE FSLIT("Monad") monadClassKey +thenMName = methName monadClassName FSLIT(">>") thenMClassOpKey +bindMName = methName monadClassName FSLIT(">>=") bindMClassOpKey +returnMName = methName monadClassName FSLIT("return") returnMClassOpKey +failMName = methName monadClassName FSLIT("fail") failMClassOpKey -- Random PrelBase functions -otherwiseIdName = varQual pREL_BASE_Name FSLIT("otherwise") otherwiseIdKey -foldrName = varQual pREL_BASE_Name FSLIT("foldr") foldrIdKey -buildName = varQual pREL_BASE_Name FSLIT("build") buildIdKey -augmentName = varQual pREL_BASE_Name FSLIT("augment") augmentIdKey -appendName = varQual pREL_BASE_Name FSLIT("++") appendIdKey -andName = varQual pREL_BASE_Name FSLIT("&&") andIdKey -orName = varQual pREL_BASE_Name FSLIT("||") orIdKey -assertName = varQual pREL_BASE_Name FSLIT("assert") assertIdKey -lazyIdName = wVarQual pREL_BASE_Name FSLIT("lazy") lazyIdKey +otherwiseIdName = varQual pREL_BASE FSLIT("otherwise") otherwiseIdKey +foldrName = varQual pREL_BASE FSLIT("foldr") foldrIdKey +buildName = varQual pREL_BASE FSLIT("build") buildIdKey +augmentName = varQual pREL_BASE FSLIT("augment") augmentIdKey +appendName = varQual pREL_BASE FSLIT("++") appendIdKey +andName = varQual pREL_BASE FSLIT("&&") andIdKey +orName = varQual pREL_BASE FSLIT("||") orIdKey +assertName = varQual pREL_BASE FSLIT("assert") assertIdKey -- PrelTup -fstName = varQual pREL_TUP_Name FSLIT("fst") fstIdKey -sndName = varQual pREL_TUP_Name FSLIT("snd") sndIdKey +fstName = varQual pREL_TUP FSLIT("fst") fstIdKey +sndName = varQual pREL_TUP FSLIT("snd") sndIdKey -- Module PrelNum -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 = wTcQual pREL_NUM_Name FSLIT("Integer") integerTyConKey -smallIntegerDataConName = wDataQual pREL_NUM_Name FSLIT("S#") smallIntegerDataConKey -largeIntegerDataConName = wDataQual pREL_NUM_Name FSLIT("J#") largeIntegerDataConKey +numClassName = clsQual pREL_NUM FSLIT("Num") numClassKey +fromIntegerName = methName numClassName FSLIT("fromInteger") fromIntegerClassOpKey +minusName = methName numClassName FSLIT("-") minusClassOpKey +negateName = methName numClassName FSLIT("negate") negateClassOpKey +plusIntegerName = varQual pREL_NUM FSLIT("plusInteger") plusIntegerIdKey +timesIntegerName = varQual pREL_NUM FSLIT("timesInteger") timesIntegerIdKey +integerTyConName = tcQual pREL_NUM FSLIT("Integer") integerTyConKey +smallIntegerDataConName = conName integerTyConName FSLIT("S#") smallIntegerDataConKey +largeIntegerDataConName = conName integerTyConName FSLIT("J#") largeIntegerDataConKey -- PrelReal types and classes -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 +rationalTyConName = tcQual pREL_REAL FSLIT("Rational") rationalTyConKey +ratioTyConName = tcQual pREL_REAL FSLIT("Ratio") ratioTyConKey +ratioDataConName = conName ratioTyConName FSLIT(":%") ratioDataConKey +realClassName = clsQual pREL_REAL FSLIT("Real") realClassKey +integralClassName = clsQual pREL_REAL FSLIT("Integral") integralClassKey +realFracClassName = clsQual pREL_REAL FSLIT("RealFrac") realFracClassKey +fractionalClassName = clsQual pREL_REAL FSLIT("Fractional") fractionalClassKey +fromRationalName = methName fractionalClassName FSLIT("fromRational") fromRationalClassOpKey -- PrelFloat classes -floatTyConName = wTcQual pREL_FLOAT_Name FSLIT("Float") floatTyConKey -floatDataConName = wDataQual pREL_FLOAT_Name FSLIT("F#") floatDataConKey -doubleTyConName = wTcQual pREL_FLOAT_Name FSLIT("Double") doubleTyConKey -doubleDataConName = wDataQual pREL_FLOAT_Name FSLIT("D#") doubleDataConKey -floatingClassName = clsQual pREL_FLOAT_Name FSLIT("Floating") floatingClassKey -realFloatClassName = clsQual pREL_FLOAT_Name FSLIT("RealFloat") realFloatClassKey +floatingClassName = clsQual pREL_FLOAT FSLIT("Floating") floatingClassKey +realFloatClassName = clsQual pREL_FLOAT FSLIT("RealFloat") realFloatClassKey -- Class Ix -ixClassName = clsQual pREL_ARR_Name FSLIT("Ix") ixClassKey +ixClassName = clsQual pREL_ARR FSLIT("Ix") ixClassKey + +-- Class Typeable and Data +typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey +dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey + +-- Error module +assertErrorName = varQual pREL_ERR FSLIT("assertError") assertErrorIdKey -- Enum module (Enum, Bounded) -enumClassName = clsQual pREL_ENUM_Name FSLIT("Enum") enumClassKey -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 -boundedClassName = clsQual pREL_ENUM_Name FSLIT("Bounded") boundedClassKey +enumClassName = clsQual pREL_ENUM FSLIT("Enum") enumClassKey +enumFromName = methName enumClassName FSLIT("enumFrom") enumFromClassOpKey +enumFromToName = methName enumClassName FSLIT("enumFromTo") enumFromToClassOpKey +enumFromThenName = methName enumClassName FSLIT("enumFromThen") enumFromThenClassOpKey +enumFromThenToName = methName enumClassName FSLIT("enumFromThenTo") enumFromThenToClassOpKey +boundedClassName = clsQual pREL_ENUM FSLIT("Bounded") boundedClassKey -- List functions -concatName = varQual pREL_LIST_Name FSLIT("concat") concatIdKey -filterName = varQual pREL_LIST_Name FSLIT("filter") filterIdKey -zipName = varQual pREL_LIST_Name FSLIT("zip") zipIdKey - --- MetaHaskell Extension, "the smart constructors" --- text3 from Meta/work/gen.hs -intLName = varQual mETA_META_Name FSLIT("intL") intLIdKey -charLName = varQual mETA_META_Name FSLIT("charL") charLIdKey -plitName = varQual mETA_META_Name FSLIT("plit") plitIdKey -pvarName = varQual mETA_META_Name FSLIT("pvar") pvarIdKey -ptupName = varQual mETA_META_Name FSLIT("ptup") ptupIdKey -pconName = varQual mETA_META_Name FSLIT("pcon") pconIdKey -ptildeName = varQual mETA_META_Name FSLIT("ptilde") ptildeIdKey -paspatName = varQual mETA_META_Name FSLIT("paspat") paspatIdKey -pwildName = varQual mETA_META_Name FSLIT("pwild") pwildIdKey -varName = varQual mETA_META_Name FSLIT("var") varIdKey -conName = varQual mETA_META_Name FSLIT("con") conIdKey -litName = varQual mETA_META_Name FSLIT("lit") litIdKey -appName = varQual mETA_META_Name FSLIT("app") appIdKey -infixEName = varQual mETA_META_Name FSLIT("infixE") infixEIdKey -lamName = varQual mETA_META_Name FSLIT("lam") lamIdKey -tupName = varQual mETA_META_Name FSLIT("tup") tupIdKey -doEName = varQual mETA_META_Name FSLIT("doE") doEIdKey -compName = varQual mETA_META_Name FSLIT("comp") compIdKey -listExpName = varQual mETA_META_Name FSLIT("listExp") listExpIdKey -condName = varQual mETA_META_Name FSLIT("cond") condIdKey -letEName = varQual mETA_META_Name FSLIT("letE") letEIdKey -caseEName = varQual mETA_META_Name FSLIT("caseE") caseEIdKey -infixAppName = varQual mETA_META_Name FSLIT("infixApp") infixAppIdKey -sectionLName = varQual mETA_META_Name FSLIT("sectionL") sectionLIdKey -sectionRName = varQual mETA_META_Name FSLIT("sectionR") sectionRIdKey -guardedName = varQual mETA_META_Name FSLIT("guarded") guardedIdKey -normalName = varQual mETA_META_Name FSLIT("normal") normalIdKey -bindStName = varQual mETA_META_Name FSLIT("bindSt") bindStIdKey -letStName = varQual mETA_META_Name FSLIT("letSt") letStIdKey -noBindStName = varQual mETA_META_Name FSLIT("noBindSt") noBindStIdKey -parStName = varQual mETA_META_Name FSLIT("parSt") parStIdKey -fromName = varQual mETA_META_Name FSLIT("from") fromIdKey -fromThenName = varQual mETA_META_Name FSLIT("fromThen") fromThenIdKey -fromToName = varQual mETA_META_Name FSLIT("fromTo") fromToIdKey -fromThenToName = varQual mETA_META_Name FSLIT("fromThenTo") fromThenToIdKey -liftName = varQual mETA_META_Name FSLIT("lift") liftIdKey -gensymName = varQual mETA_META_Name FSLIT("gensym") gensymIdKey -returnQName = varQual mETA_META_Name FSLIT("returnQ") returnQIdKey -bindQName = varQual mETA_META_Name FSLIT("bindQ") bindQIdKey -funName = varQual mETA_META_Name FSLIT("fun") funIdKey -valName = varQual mETA_META_Name FSLIT("val") valIdKey -matchName = varQual mETA_META_Name FSLIT("match") matchIdKey -clauseName = varQual mETA_META_Name FSLIT("clause") clauseIdKey -protoName = varQual mETA_META_Name FSLIT("proto") protoIdKey -exprTyConName = tcQual mETA_META_Name FSLIT("Expr") exprTyConKey -declTyConName = tcQual mETA_META_Name FSLIT("Decl") declTyConKey -pattTyConName = tcQual mETA_META_Name FSLIT("Patt") pattTyConKey -mtchTyConName = tcQual mETA_META_Name FSLIT("Mtch") mtchTyConKey -clseTyConName = tcQual mETA_META_Name FSLIT("Clse") clseTyConKey -stmtTyConName = tcQual mETA_META_Name FSLIT("Stmt") stmtTyConKey - -qTyConName = tcQual mETA_META_Name FSLIT("Q") qTyConKey -expTyConName = tcQual mETA_META_Name FSLIT("Exp") expTyConKey -matTyConName = tcQual mETA_META_Name FSLIT("Mat") matTyConKey -clsTyConName = tcQual mETA_META_Name FSLIT("Cls") clsTyConKey +concatName = varQual pREL_LIST FSLIT("concat") concatIdKey +filterName = varQual pREL_LIST FSLIT("filter") filterIdKey +zipName = varQual pREL_LIST FSLIT("zip") zipIdKey -- Class Show -showClassName = clsQual pREL_SHOW_Name FSLIT("Show") showClassKey +showClassName = clsQual pREL_SHOW FSLIT("Show") showClassKey -- Class Read -readClassName = clsQual pREL_READ_Name FSLIT("Read") readClassKey +readClassName = clsQual pREL_READ FSLIT("Read") readClassKey -- parallel array types and functions -enumFromToPName = varQual pREL_PARR_Name FSLIT("enumFromToP") enumFromToPIdKey -enumFromThenToPName= varQual pREL_PARR_Name FSLIT("enumFromThenToP") enumFromThenToPIdKey -parrTyConName = wTcQual pREL_PARR_Name FSLIT("[::]") parrTyConKey -parrDataConName = wDataQual 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 +enumFromToPName = varQual pREL_PARR FSLIT("enumFromToP") enumFromToPIdKey +enumFromThenToPName= varQual pREL_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey +nullPName = varQual pREL_PARR FSLIT("nullP") nullPIdKey +lengthPName = varQual pREL_PARR FSLIT("lengthP") lengthPIdKey +replicatePName = varQual pREL_PARR FSLIT("replicateP") replicatePIdKey +mapPName = varQual pREL_PARR FSLIT("mapP") mapPIdKey +filterPName = varQual pREL_PARR FSLIT("filterP") filterPIdKey +zipPName = varQual pREL_PARR FSLIT("zipP") zipPIdKey +crossPName = varQual pREL_PARR FSLIT("crossP") crossPIdKey +indexPName = varQual pREL_PARR FSLIT("!:") indexPIdKey +toPName = varQual pREL_PARR FSLIT("toP") toPIdKey +bpermutePName = varQual pREL_PARR FSLIT("bpermuteP") bpermutePIdKey +bpermuteDftPName = varQual pREL_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey +indexOfPName = varQual pREL_PARR FSLIT("indexOfP") indexOfPIdKey -- IOBase things -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 +ioTyConName = tcQual pREL_IO_BASE FSLIT("IO") ioTyConKey +ioDataConName = conName ioTyConName FSLIT("IO") ioDataConKey +thenIOName = varQual pREL_IO_BASE FSLIT("thenIO") thenIOIdKey +bindIOName = varQual pREL_IO_BASE FSLIT("bindIO") bindIOIdKey +returnIOName = varQual pREL_IO_BASE FSLIT("returnIO") returnIOIdKey +failIOName = varQual pREL_IO_BASE FSLIT("failIO") failIOIdKey -- IO things -printName = varQual sYSTEM_IO_Name FSLIT("print") printIdKey +printName = varQual sYSTEM_IO FSLIT("print") printIdKey -- Int, Word, and Addr things -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 +int8TyConName = tcQual pREL_INT FSLIT("Int8") int8TyConKey +int16TyConName = tcQual pREL_INT FSLIT("Int16") int16TyConKey +int32TyConName = tcQual pREL_INT FSLIT("Int32") int32TyConKey +int64TyConName = tcQual pREL_INT FSLIT("Int64") int64TyConKey -- Word module -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 = wTcQual pREL_WORD_Name FSLIT("Word") wordTyConKey -wordDataConName = wDataQual pREL_WORD_Name FSLIT("W#") wordDataConKey +word8TyConName = tcQual pREL_WORD FSLIT("Word8") word8TyConKey +word16TyConName = tcQual pREL_WORD FSLIT("Word16") word16TyConKey +word32TyConName = tcQual pREL_WORD FSLIT("Word32") word32TyConKey +word64TyConName = tcQual pREL_WORD FSLIT("Word64") word64TyConKey +wordTyConName = tcQual pREL_WORD FSLIT("Word") wordTyConKey +wordDataConName = conName wordTyConName FSLIT("W#") wordDataConKey -- Addr module -addrTyConName = wTcQual aDDR_Name FSLIT("Addr") addrTyConKey -addrDataConName = wDataQual aDDR_Name FSLIT("A#") addrDataConKey +addrTyConName = tcQual aDDR FSLIT("Addr") addrTyConKey -- PrelPtr module -ptrTyConName = wTcQual pREL_PTR_Name FSLIT("Ptr") ptrTyConKey -ptrDataConName = wDataQual pREL_PTR_Name FSLIT("Ptr") ptrDataConKey -funPtrTyConName = wTcQual pREL_PTR_Name FSLIT("FunPtr") funPtrTyConKey -funPtrDataConName = wDataQual pREL_PTR_Name FSLIT("FunPtr") funPtrDataConKey +ptrTyConName = tcQual pREL_PTR FSLIT("Ptr") ptrTyConKey +funPtrTyConName = tcQual pREL_PTR FSLIT("FunPtr") funPtrTyConKey -- Byte array types -byteArrayTyConName = tcQual pREL_BYTEARR_Name FSLIT("ByteArray") byteArrayTyConKey -mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name FSLIT("MutableByteArray") mutableByteArrayTyConKey +byteArrayTyConName = tcQual pREL_BYTEARR FSLIT("ByteArray") byteArrayTyConKey +mutableByteArrayTyConName = tcQual pREL_BYTEARR FSLIT("MutableByteArray") mutableByteArrayTyConKey -- Foreign objects and weak pointers -stablePtrTyConName = tcQual pREL_STABLE_Name FSLIT("StablePtr") stablePtrTyConKey -stablePtrDataConName = dataQual pREL_STABLE_Name FSLIT("StablePtr") stablePtrDataConKey -newStablePtrName = varQual pREL_STABLE_Name FSLIT("newStablePtr") newStablePtrIdKey - --- Error module -errorName = wVarQual pREL_ERR_Name FSLIT("error") errorIdKey -assertErrorName = wVarQual pREL_ERR_Name FSLIT("assertError") assertErrorIdKey -recSelErrorName = wVarQual pREL_ERR_Name FSLIT("recSelError") recSelErrorIdKey -runtimeErrorName = wVarQual pREL_ERR_Name FSLIT("runtimeError") runtimeErrorIdKey -irrefutPatErrorName = wVarQual pREL_ERR_Name FSLIT("irrefutPatError") irrefutPatErrorIdKey -recConErrorName = wVarQual pREL_ERR_Name FSLIT("recConError") recConErrorIdKey -patErrorName = wVarQual pREL_ERR_Name FSLIT("patError") patErrorIdKey -noMethodBindingErrorName = wVarQual pREL_ERR_Name FSLIT("noMethodBindingError") noMethodBindingErrorIdKey -nonExhaustiveGuardsErrorName - = wVarQual pREL_ERR_Name FSLIT("nonExhaustiveGuardsError") nonExhaustiveGuardsErrorIdKey +stablePtrTyConName = tcQual pREL_STABLE FSLIT("StablePtr") stablePtrTyConKey +newStablePtrName = varQual pREL_STABLE FSLIT("newStablePtr") newStablePtrIdKey -- PrelST module -runSTRepName = varQual pREL_ST_Name FSLIT("runSTRep") runSTRepIdKey +runSTRepName = varQual pREL_ST FSLIT("runSTRep") runSTRepIdKey -- The "split" Id for splittable implicit parameters -splitName = varQual gLA_EXTS_Name FSLIT("split") splitIdKey -\end{code} - -%************************************************************************ -%* * -\subsection{Standard groups of names} -%* * -%************************************************************************ - -\begin{code} -templateHaskellNames :: NameSet --- The names that are implicitly mentioned by ``bracket'' --- Should stay in sync with the import list of DsMeta -templateHaskellNames - = mkNameSet [ intLName,charLName, plitName, pvarName, ptupName, - pconName, ptildeName, paspatName, pwildName, - varName, conName, litName, appName, lamName, - tupName, doEName, compName, - listExpName, condName, letEName, caseEName, - infixAppName, guardedName, normalName, - bindStName, letStName, noBindStName, parStName, - fromName, fromThenName, fromToName, fromThenToName, - funName, valName, liftName,gensymName, bindQName, - appendName, matchName, clauseName ] +splitName = varQual gLA_EXTS FSLIT("split") splitIdKey + +-- Recursive-do notation +mfixName = varQual mONAD_FIX FSLIT("mfix") mfixIdKey + +-- Arrow notation +arrAName = varQual aRROW FSLIT("arr") arrAIdKey +composeAName = varQual aRROW FSLIT(">>>") composeAIdKey +firstAName = varQual aRROW FSLIT("first") firstAIdKey +appAName = varQual aRROW FSLIT("app") appAIdKey +choiceAName = varQual aRROW FSLIT("|||") choiceAIdKey +loopAName = varQual aRROW FSLIT("loop") loopAIdKey + +-- dotnet interop +objectTyConName = tcQual dOTNET FSLIT("Object") objectTyConKey + -- objectTyConName was "wTcQual", but that's gone now, and + -- I can't see why it was wired in anyway... +unmarshalObjectName = varQual dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey +marshalObjectName = varQual dOTNET FSLIT("marshalObject") marshalObjectIdKey +marshalStringName = varQual dOTNET FSLIT("marshalString") marshalStringIdKey +unmarshalStringName = varQual dOTNET FSLIT("unmarshalString") unmarshalStringIdKey +checkDotnetResName = varQual dOTNET FSLIT("checkResult") checkDotnetResNameIdKey \end{code} %************************************************************************ @@ -840,29 +673,23 @@ templateHaskellNames All these are original names; hence mkOrig \begin{code} -varQual = mk_known_key_name OccNameAlias.varName -- Note use of local alias vName -dataQual = mk_known_key_name dataName +varQual = mk_known_key_name varName tcQual = mk_known_key_name tcName clsQual = mk_known_key_name clsName -wVarQual = mk_wired_in_name OccNameAlias.varName -- The wired-in analogues -wDataQual = mk_wired_in_name dataName -wTcQual = mk_wired_in_name tcName - -varQual_RDR mod str = mkOrig mod (mkOccFS OccNameAlias.varName str) -- note use of local alias vName -tcQual_RDR mod str = mkOrig mod (mkOccFS tcName str) -clsQual_RDR mod str = mkOrig mod (mkOccFS clsName str) -dataQual_RDR mod str = mkOrig mod (mkOccFS dataName str) - mk_known_key_name space mod str uniq - = mkKnownKeyExternalName mod (mkOccFS space str) uniq -mk_wired_in_name space mod str uniq - = mkWiredInName (mkVanillaModule mod) (mkOccFS space str) uniq - -kindQual str uq = mkInternalName uq (mkKindOccFS tcName str) noSrcLoc - -- 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 + = mkExternalName uniq mod (mkOccFS space str) + Nothing noSrcLoc + +conName :: Name -> FastString -> Unique -> Name +conName tycon occ uniq + = mkExternalName uniq (nameModule tycon) (mkOccFS dataName occ) + (Just tycon) noSrcLoc + +methName :: Name -> FastString -> Unique -> Name +methName cls occ uniq + = mkExternalName uniq (nameModule cls) (mkOccFS varName occ) + (Just cls) noSrcLoc \end{code} %************************************************************************ @@ -876,10 +703,12 @@ kindQual str uq = mkInternalName uq (mkKindOccFS tcName str) noSrcLoc boundedClassKey = mkPreludeClassUnique 1 enumClassKey = mkPreludeClassUnique 2 eqClassKey = mkPreludeClassUnique 3 +typeableClassKey = mkPreludeClassUnique 4 floatingClassKey = mkPreludeClassUnique 5 fractionalClassKey = mkPreludeClassUnique 6 integralClassKey = mkPreludeClassUnique 7 monadClassKey = mkPreludeClassUnique 8 +dataClassKey = mkPreludeClassUnique 9 functorClassKey = mkPreludeClassUnique 10 numClassKey = mkPreludeClassUnique 11 ordClassKey = mkPreludeClassUnique 12 @@ -888,10 +717,6 @@ realClassKey = mkPreludeClassUnique 14 realFloatClassKey = mkPreludeClassUnique 15 realFracClassKey = mkPreludeClassUnique 16 showClassKey = mkPreludeClassUnique 17 - -cCallableClassKey = mkPreludeClassUnique 18 -cReturnableClassKey = mkPreludeClassUnique 19 - ixClassKey = mkPreludeClassUnique 20 \end{code} @@ -961,11 +786,6 @@ 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 79 plusTyConKey = mkPreludeTyConUnique 80 @@ -974,17 +794,14 @@ genUnitTyConKey = mkPreludeTyConUnique 81 -- Parallel array type constructor parrTyConKey = mkPreludeTyConUnique 82 --- Template Haskell -qTyConKey = mkPreludeTyConUnique 83 -exprTyConKey = mkPreludeTyConUnique 84 -declTyConKey = mkPreludeTyConUnique 85 -pattTyConKey = mkPreludeTyConUnique 86 -mtchTyConKey = mkPreludeTyConUnique 87 -clseTyConKey = mkPreludeTyConUnique 88 -stmtTyConKey = mkPreludeTyConUnique 89 -expTyConKey = mkPreludeTyConUnique 90 -matTyConKey = mkPreludeTyConUnique 91 -clsTyConKey = mkPreludeTyConUnique 92 +-- dotnet interop +objectTyConKey = mkPreludeTyConUnique 83 + +eitherTyConKey = mkPreludeTyConUnique 84 + +---------------- Template Haskell ------------------- +-- USES TyConUniques 100-119 +----------------------------------------------------- unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} @@ -996,7 +813,6 @@ unitTyConKey = mkTupleTyConUnique Boxed 0 %************************************************************************ \begin{code} -addrDataConKey = mkPreludeDataConUnique 0 charDataConKey = mkPreludeDataConUnique 1 consDataConKey = mkPreludeDataConUnique 2 doubleDataConKey = mkPreludeDataConUnique 3 @@ -1007,13 +823,10 @@ smallIntegerDataConKey = mkPreludeDataConUnique 7 largeIntegerDataConKey = mkPreludeDataConUnique 8 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 20 @@ -1023,6 +836,9 @@ genUnitDataConKey = mkPreludeDataConUnique 23 -- Data constructor for parallel arrays parrDataConKey = mkPreludeDataConUnique 24 + +leftDataConKey = mkPreludeDataConUnique 25 +rightDataConKey = mkPreludeDataConUnique 26 \end{code} %************************************************************************ @@ -1033,7 +849,6 @@ parrDataConKey = mkPreludeDataConUnique 24 \begin{code} absentErrorIdKey = mkPreludeMiscIdUnique 1 -getTagIdKey = mkPreludeMiscIdUnique 2 augmentIdKey = mkPreludeMiscIdUnique 3 appendIdKey = mkPreludeMiscIdUnique 4 buildIdKey = mkPreludeMiscIdUnique 5 @@ -1085,7 +900,7 @@ otherwiseIdKey = mkPreludeMiscIdUnique 51 assertIdKey = mkPreludeMiscIdUnique 53 runSTRepIdKey = mkPreludeMiscIdUnique 54 -dollarMainKey = mkPreludeMiscIdUnique 55 +rootMainKey = mkPreludeMiscIdUnique 55 runMainKey = mkPreludeMiscIdUnique 56 andIdKey = mkPreludeMiscIdUnique 57 @@ -1109,6 +924,14 @@ enumFromThenToPIdKey = mkPreludeMiscIdUnique 90 bpermutePIdKey = mkPreludeMiscIdUnique 91 bpermuteDftPIdKey = mkPreludeMiscIdUnique 92 indexOfPIdKey = mkPreludeMiscIdUnique 93 + +-- dotnet interop +unmarshalObjectIdKey = mkPreludeMiscIdUnique 94 +marshalObjectIdKey = mkPreludeMiscIdUnique 95 +marshalStringIdKey = mkPreludeMiscIdUnique 96 +unmarshalStringIdKey = mkPreludeMiscIdUnique 97 +checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98 + \end{code} Certain class operations from Prelude classes. They get their own @@ -1134,51 +957,20 @@ bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>) returnMClassOpKey = mkPreludeMiscIdUnique 117 --- MetaHaskell Extension, (text4 118) from Meta/work/gen.hs -intLIdKey = mkPreludeMiscIdUnique 118 -charLIdKey = mkPreludeMiscIdUnique 119 -plitIdKey = mkPreludeMiscIdUnique 120 -pvarIdKey = mkPreludeMiscIdUnique 121 -ptupIdKey = mkPreludeMiscIdUnique 122 -pconIdKey = mkPreludeMiscIdUnique 123 -ptildeIdKey = mkPreludeMiscIdUnique 124 -paspatIdKey = mkPreludeMiscIdUnique 125 -pwildIdKey = mkPreludeMiscIdUnique 126 -varIdKey = mkPreludeMiscIdUnique 127 -conIdKey = mkPreludeMiscIdUnique 128 -litIdKey = mkPreludeMiscIdUnique 129 -appIdKey = mkPreludeMiscIdUnique 130 -infixEIdKey = mkPreludeMiscIdUnique 131 -lamIdKey = mkPreludeMiscIdUnique 132 -tupIdKey = mkPreludeMiscIdUnique 133 -doEIdKey = mkPreludeMiscIdUnique 134 -compIdKey = mkPreludeMiscIdUnique 135 -listExpIdKey = mkPreludeMiscIdUnique 137 -condIdKey = mkPreludeMiscIdUnique 138 -letEIdKey = mkPreludeMiscIdUnique 139 -caseEIdKey = mkPreludeMiscIdUnique 140 -infixAppIdKey = mkPreludeMiscIdUnique 141 -sectionLIdKey = mkPreludeMiscIdUnique 142 -sectionRIdKey = mkPreludeMiscIdUnique 143 -guardedIdKey = mkPreludeMiscIdUnique 144 -normalIdKey = mkPreludeMiscIdUnique 145 -bindStIdKey = mkPreludeMiscIdUnique 146 -letStIdKey = mkPreludeMiscIdUnique 147 -noBindStIdKey = mkPreludeMiscIdUnique 148 -parStIdKey = mkPreludeMiscIdUnique 149 -fromIdKey = mkPreludeMiscIdUnique 150 -fromThenIdKey = mkPreludeMiscIdUnique 151 -fromToIdKey = mkPreludeMiscIdUnique 152 -fromThenToIdKey = mkPreludeMiscIdUnique 153 -liftIdKey = mkPreludeMiscIdUnique 154 -gensymIdKey = mkPreludeMiscIdUnique 155 -returnQIdKey = mkPreludeMiscIdUnique 156 -bindQIdKey = mkPreludeMiscIdUnique 157 -funIdKey = mkPreludeMiscIdUnique 158 -valIdKey = mkPreludeMiscIdUnique 159 -protoIdKey = mkPreludeMiscIdUnique 160 -matchIdKey = mkPreludeMiscIdUnique 161 -clauseIdKey = mkPreludeMiscIdUnique 162 +-- Recursive do notation +mfixIdKey = mkPreludeMiscIdUnique 118 + +-- Arrow notation +arrAIdKey = mkPreludeMiscIdUnique 119 +composeAIdKey = mkPreludeMiscIdUnique 120 -- >>> +firstAIdKey = mkPreludeMiscIdUnique 121 +appAIdKey = mkPreludeMiscIdUnique 122 +choiceAIdKey = mkPreludeMiscIdUnique 123 -- ||| +loopAIdKey = mkPreludeMiscIdUnique 124 + +---------------- Template Haskell ------------------- +-- USES IdUniques 200-299 +----------------------------------------------------- \end{code} @@ -1249,24 +1041,9 @@ needsDataDeclCtxtClassKeys = -- see comments in TcDeriv [ readClassKey ] -cCallishClassKeys = - [ cCallableClassKey - , cReturnableClassKey - ] +standardClassKeys = derivableClassKeys ++ numericClassKeys -standardClassKeys - = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys - -- - -- We have to have "CCallable" and "CReturnable" in the standard - -- classes, so that if you go... - -- - -- _ccall_ foo ... 93{-numeric literal-} ... - -- - -- ... it can do The Right Thing on the 93. - -noDictClassKeys -- These classes are used only for type annotations; - -- they are not implemented by dictionaries, ever. - = cCallishClassKeys +noDictClassKeys = [] -- ToDo: remove? \end{code} @derivableClassKeys@ is also used in checking \tr{deriving} constructs