X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fprelude%2FPrelNames.lhs;h=0aadee56b7b4ef93ad5b418241f57c029a4644a7;hb=4546262dd278085373862ae5820c7ae17a0816c4;hp=9c513396d5e8fb04ff234ad1bbeebbfdd83d98c9;hpb=3a99fa889bdff0c86df20cb18c71d30e30a79b43;p=ghc-hetmet.git diff --git a/compiler/prelude/PrelNames.lhs b/compiler/prelude/PrelNames.lhs index 9c51339..0aadee5 100644 --- a/compiler/prelude/PrelNames.lhs +++ b/compiler/prelude/PrelNames.lhs @@ -49,10 +49,8 @@ module PrelNames ( #include "HsVersions.h" -import PackageConfig -import Module ( Module, ModuleName, mkModule, mkModuleNameFS ) -import OccName ( dataName, tcName, clsName, varName, mkOccNameFS, - mkVarOccFS ) +import Module +import OccName import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual ) import Unique ( Unique, Uniquable(..), hasKey, mkPreludeMiscIdUnique, mkPreludeDataConUnique, @@ -61,7 +59,7 @@ import Unique ( Unique, Uniquable(..), hasKey, ) import BasicTypes ( Boxity(..), Arity ) import Name ( Name, mkInternalName, mkExternalName ) -import SrcLoc ( noSrcLoc ) +import SrcLoc import FastString \end{code} @@ -75,14 +73,15 @@ import FastString This *local* name is used by the interactive stuff \begin{code} -itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcLoc +itName :: Unique -> Name +itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcSpan \end{code} \begin{code} -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly -- during compiler debugging. mkUnboundName :: RdrName -> Name -mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcLoc +mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan isUnboundName :: Name -> Bool isUnboundName name = name `hasKey` unboundKey @@ -109,9 +108,10 @@ basicKnownKeyNames runMainIOName, orderingTyConName, rationalTyConName, + stringTyConName, ratioDataConName, ratioTyConName, - integerTyConName, smallIntegerDataConName, largeIntegerDataConName, + integerTyConName, smallIntegerName, -- Classes. *Must* include: -- classes that are grabbed by key (e.g., eqClassKey) @@ -130,11 +130,15 @@ basicKnownKeyNames realFracClassName, -- numeric realFloatClassName, -- numeric dataClassName, + isStringClassName, -- Numeric stuff negateName, minusName, fromRationalName, fromIntegerName, geName, eqName, + + -- String stuff + fromStringName, -- Enum stuff enumFromName, enumFromThenName, @@ -164,17 +168,20 @@ basicKnownKeyNames -- Stable pointers newStablePtrName, + -- GHC Extensions + groupWithName, + -- Strings and lists unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName, unpackCStringUtf8Name, -- List operations - concatName, filterName, + concatName, filterName, mapName, zipName, foldrName, buildName, augmentName, appendName, -- Parallel array operations - nullPName, lengthPName, replicatePName, mapPName, - filterPName, zipPName, crossPName, indexPName, + nullPName, lengthPName, replicatePName, singletonPName, mapPName, + filterPName, zipPName, crossMapPName, indexPName, toPName, bpermutePName, bpermuteDftPName, indexOfPName, -- FFI primitive types that are not wired-in. @@ -183,10 +190,10 @@ basicKnownKeyNames wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName, -- Others - otherwiseIdName, + otherwiseIdName, inlineIdName, plusIntegerName, timesIntegerName, eqStringName, assertName, breakpointName, breakpointCondName, - breakpointAutoName, opaqueTyConName, + breakpointAutoName, opaqueTyConName, assertErrorName, runSTRepName, printName, fstName, sndName, @@ -221,17 +228,31 @@ genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName] --MetaHaskell Extension Add a new module here \begin{code} +pRELUDE :: Module pRELUDE = mkBaseModule_ pRELUDE_NAME -gHC_PRIM = mkBaseModule FSLIT("GHC.Prim") -- Primitive types and values + +gHC_PRIM, gHC_BOOL, gHC_GENERICS, gHC_BASE, gHC_ENUM, gHC_SHOW, gHC_READ, + gHC_NUM, gHC_INTEGER, gHC_LIST, gHC_PARR, dATA_TUP, dATA_EITHER, + dATA_STRING, gHC_PACK, gHC_CONC, gHC_IO_BASE, gHC_ST, gHC_ARR, + gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL, gHC_FLOAT, + gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS, dOTNET, + rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, + gHC_DESUGAR, rANDOM, gHC_EXTS :: Module +gHC_PRIM = mkPrimModule FSLIT("GHC.Prim") -- Primitive types and values +gHC_BOOL = mkPrimModule FSLIT("GHC.Bool") +gHC_ORDERING = mkPrimModule FSLIT("GHC.Ordering") +gHC_GENERICS = mkPrimModule FSLIT("GHC.Generics") gHC_BASE = mkBaseModule FSLIT("GHC.Base") gHC_ENUM = mkBaseModule FSLIT("GHC.Enum") gHC_SHOW = mkBaseModule FSLIT("GHC.Show") gHC_READ = mkBaseModule FSLIT("GHC.Read") gHC_NUM = mkBaseModule FSLIT("GHC.Num") +gHC_INTEGER = mkIntegerModule FSLIT("GHC.Integer") gHC_LIST = mkBaseModule FSLIT("GHC.List") gHC_PARR = mkBaseModule FSLIT("GHC.PArr") dATA_TUP = mkBaseModule FSLIT("Data.Tuple") dATA_EITHER = mkBaseModule FSLIT("Data.Either") +dATA_STRING = mkBaseModule FSLIT("Data.String") gHC_PACK = mkBaseModule FSLIT("GHC.Pack") gHC_CONC = mkBaseModule FSLIT("GHC.Conc") gHC_IO_BASE = mkBaseModule FSLIT("GHC.IOBase") @@ -250,15 +271,17 @@ tYPEABLE = mkBaseModule FSLIT("Data.Typeable") gENERICS = mkBaseModule FSLIT("Data.Generics.Basics") dOTNET = mkBaseModule FSLIT("GHC.Dotnet") rEAD_PREC = mkBaseModule FSLIT("Text.ParserCombinators.ReadPrec") -lEX = mkBaseModule FSLIT("Text.Read.Lex") +lEX = mkBaseModule FSLIT("Text.Read.Lex") gHC_INT = mkBaseModule FSLIT("GHC.Int") gHC_WORD = mkBaseModule FSLIT("GHC.Word") mONAD = mkBaseModule FSLIT("Control.Monad") mONAD_FIX = mkBaseModule FSLIT("Control.Monad.Fix") aRROW = mkBaseModule FSLIT("Control.Arrow") +gHC_DESUGAR = mkBaseModule FSLIT("GHC.Desugar") rANDOM = mkBaseModule FSLIT("System.Random") -gLA_EXTS = mkBaseModule FSLIT("GHC.Exts") +gHC_EXTS = mkBaseModule FSLIT("GHC.Exts") +mAIN, rOOT_MAIN :: Module mAIN = mkMainModule_ mAIN_NAME rOOT_MAIN = mkMainModule FSLIT(":Main") -- Root module for initialisation @@ -266,12 +289,20 @@ rOOT_MAIN = mkMainModule FSLIT(":Main") -- Root module for initialisation -- 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, thFAKE :: Module iNTERACTIVE = mkMainModule FSLIT(":Interactive") thFAKE = mkMainModule FSLIT(":THFake") +pRELUDE_NAME, mAIN_NAME :: ModuleName pRELUDE_NAME = mkModuleNameFS FSLIT("Prelude") mAIN_NAME = mkModuleNameFS FSLIT("Main") +mkPrimModule :: FastString -> Module +mkPrimModule m = mkModule primPackageId (mkModuleNameFS m) + +mkIntegerModule :: FastString -> Module +mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m) + mkBaseModule :: FastString -> Module mkBaseModule m = mkModule basePackageId (mkModuleNameFS m) @@ -306,73 +337,103 @@ mkTupleModule Unboxed _ = gHC_PRIM %************************************************************************ \begin{code} -main_RDR_Unqual = mkUnqual varName FSLIT("main") +main_RDR_Unqual :: RdrName +main_RDR_Unqual = mkUnqual varName FSLIT("main") -- We definitely don't want an Orig RdrName, because -- main might, in principle, be imported into module Main +forall_tv_RDR, dot_tv_RDR :: RdrName +forall_tv_RDR = mkUnqual tvName FSLIT("forall") +dot_tv_RDR = mkUnqual tvName FSLIT(".") + +eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR, + ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName eq_RDR = nameRdrName eqName ge_RDR = nameRdrName geName ne_RDR = varQual_RDR gHC_BASE FSLIT("/=") le_RDR = varQual_RDR gHC_BASE FSLIT("<=") +lt_RDR = varQual_RDR gHC_BASE FSLIT("<") gt_RDR = varQual_RDR gHC_BASE FSLIT(">") compare_RDR = varQual_RDR gHC_BASE FSLIT("compare") -ltTag_RDR = dataQual_RDR gHC_BASE FSLIT("LT") -eqTag_RDR = dataQual_RDR gHC_BASE FSLIT("EQ") -gtTag_RDR = dataQual_RDR gHC_BASE FSLIT("GT") +ltTag_RDR = dataQual_RDR gHC_ORDERING FSLIT("LT") +eqTag_RDR = dataQual_RDR gHC_ORDERING FSLIT("EQ") +gtTag_RDR = dataQual_RDR gHC_ORDERING FSLIT("GT") +eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR + :: RdrName eqClass_RDR = nameRdrName eqClassName numClass_RDR = nameRdrName numClassName ordClass_RDR = nameRdrName ordClassName enumClass_RDR = nameRdrName enumClassName monadClass_RDR = nameRdrName monadClassName +map_RDR, append_RDR :: RdrName map_RDR = varQual_RDR gHC_BASE FSLIT("map") append_RDR = varQual_RDR gHC_BASE FSLIT("++") +foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName foldr_RDR = nameRdrName foldrName build_RDR = nameRdrName buildName returnM_RDR = nameRdrName returnMName bindM_RDR = nameRdrName bindMName failM_RDR = nameRdrName failMName +and_RDR :: RdrName and_RDR = nameRdrName andName +left_RDR, right_RDR :: RdrName left_RDR = nameRdrName leftDataConName right_RDR = nameRdrName rightDataConName +fromEnum_RDR, toEnum_RDR :: RdrName fromEnum_RDR = varQual_RDR gHC_ENUM FSLIT("fromEnum") toEnum_RDR = varQual_RDR gHC_ENUM FSLIT("toEnum") +enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName enumFrom_RDR = nameRdrName enumFromName enumFromTo_RDR = nameRdrName enumFromToName enumFromThen_RDR = nameRdrName enumFromThenName enumFromThenTo_RDR = nameRdrName enumFromThenToName +ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName ratioDataCon_RDR = nameRdrName ratioDataConName plusInteger_RDR = nameRdrName plusIntegerName timesInteger_RDR = nameRdrName timesIntegerName +ioDataCon_RDR :: RdrName ioDataCon_RDR = nameRdrName ioDataConName +eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR, + unpackCStringUtf8_RDR :: RdrName eqString_RDR = nameRdrName eqStringName unpackCString_RDR = nameRdrName unpackCStringName unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name +newStablePtr_RDR, wordDataCon_RDR :: RdrName newStablePtr_RDR = nameRdrName newStablePtrName wordDataCon_RDR = dataQual_RDR gHC_WORD FSLIT("W#") +bindIO_RDR, returnIO_RDR :: RdrName bindIO_RDR = nameRdrName bindIOName returnIO_RDR = nameRdrName returnIOName +fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName fromInteger_RDR = nameRdrName fromIntegerName fromRational_RDR = nameRdrName fromRationalName minus_RDR = nameRdrName minusName times_RDR = varQual_RDR gHC_NUM FSLIT("*") plus_RDR = varQual_RDR gHC_NUM FSLIT("+") +fromString_RDR :: RdrName +fromString_RDR = nameRdrName fromStringName + +compose_RDR :: RdrName compose_RDR = varQual_RDR gHC_BASE FSLIT(".") +not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR, + range_RDR, inRange_RDR, index_RDR, + unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName not_RDR = varQual_RDR gHC_BASE FSLIT("not") getTag_RDR = varQual_RDR gHC_BASE FSLIT("getTag") succ_RDR = varQual_RDR gHC_ENUM FSLIT("succ") @@ -385,6 +446,8 @@ index_RDR = varQual_RDR gHC_ARR FSLIT("index") unsafeIndex_RDR = varQual_RDR gHC_ARR FSLIT("unsafeIndex") unsafeRangeSize_RDR = varQual_RDR gHC_ARR FSLIT("unsafeRangeSize") +readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR, + readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName readList_RDR = varQual_RDR gHC_READ FSLIT("readList") readListDefault_RDR = varQual_RDR gHC_READ FSLIT("readListDefault") readListPrec_RDR = varQual_RDR gHC_READ FSLIT("readListPrec") @@ -394,15 +457,19 @@ parens_RDR = varQual_RDR gHC_READ FSLIT("parens") choose_RDR = varQual_RDR gHC_READ FSLIT("choose") lexP_RDR = varQual_RDR gHC_READ FSLIT("lexP") +punc_RDR, ident_RDR, symbol_RDR :: RdrName punc_RDR = dataQual_RDR lEX FSLIT("Punc") ident_RDR = dataQual_RDR lEX FSLIT("Ident") symbol_RDR = dataQual_RDR lEX FSLIT("Symbol") +step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName step_RDR = varQual_RDR rEAD_PREC FSLIT("step") alt_RDR = varQual_RDR rEAD_PREC FSLIT("+++") reset_RDR = varQual_RDR rEAD_PREC FSLIT("reset") prec_RDR = varQual_RDR rEAD_PREC FSLIT("prec") +showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR, + showSpace_RDR, showParen_RDR :: RdrName showList_RDR = varQual_RDR gHC_SHOW FSLIT("showList") showList___RDR = varQual_RDR gHC_SHOW FSLIT("showList__") showsPrec_RDR = varQual_RDR gHC_SHOW FSLIT("showsPrec") @@ -410,18 +477,23 @@ showString_RDR = varQual_RDR gHC_SHOW FSLIT("showString") showSpace_RDR = varQual_RDR gHC_SHOW FSLIT("showSpace") showParen_RDR = varQual_RDR gHC_SHOW FSLIT("showParen") +typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName typeOf_RDR = varQual_RDR tYPEABLE FSLIT("typeOf") mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp") mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon") +undefined_RDR :: RdrName undefined_RDR = varQual_RDR gHC_ERR FSLIT("undefined") -crossDataCon_RDR = dataQual_RDR gHC_BASE FSLIT(":*:") -inlDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Inl") -inrDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Inr") -genUnitDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Unit") +crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName +crossDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT(":*:") +inlDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Inl") +inrDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Inr") +genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Unit") ---------------------- +varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR + :: Module -> FastString -> RdrName varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str) tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str) clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str) @@ -443,30 +515,39 @@ and it's convenient to write them all down in one place. \begin{code} +runMainIOName :: Name runMainIOName = varQual gHC_TOP_HANDLER FSLIT("runMainIO") runMainKey -orderingTyConName = tcQual gHC_BASE FSLIT("Ordering") orderingTyConKey +orderingTyConName :: Name +orderingTyConName = tcQual gHC_ORDERING FSLIT("Ordering") orderingTyConKey +eitherTyConName, leftDataConName, rightDataConName :: Name eitherTyConName = tcQual dATA_EITHER FSLIT("Either") eitherTyConKey leftDataConName = conName dATA_EITHER FSLIT("Left") leftDataConKey rightDataConName = conName dATA_EITHER FSLIT("Right") rightDataConKey -- Generics -crossTyConName = tcQual gHC_BASE FSLIT(":*:") crossTyConKey -plusTyConName = tcQual gHC_BASE FSLIT(":+:") plusTyConKey -genUnitTyConName = tcQual gHC_BASE FSLIT("Unit") genUnitTyConKey +crossTyConName, plusTyConName, genUnitTyConName :: Name +crossTyConName = tcQual gHC_GENERICS FSLIT(":*:") crossTyConKey +plusTyConName = tcQual gHC_GENERICS FSLIT(":+:") plusTyConKey +genUnitTyConName = tcQual gHC_GENERICS FSLIT("Unit") genUnitTyConKey -- Base strings Strings +unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName, + unpackCStringUtf8Name, eqStringName, stringTyConName :: Name unpackCStringName = varQual gHC_BASE FSLIT("unpackCString#") unpackCStringIdKey unpackCStringAppendName = varQual gHC_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey unpackCStringFoldrName = varQual gHC_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey unpackCStringUtf8Name = varQual gHC_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey eqStringName = varQual gHC_BASE FSLIT("eqString") eqStringIdKey +stringTyConName = tcQual gHC_BASE FSLIT("String") stringTyConKey -- The 'inline' function +inlineIdName :: Name inlineIdName = varQual gHC_BASE FSLIT("inline") inlineIdKey -- Base classes (Eq, Ord, Functor) +eqClassName, eqName, ordClassName, geName, functorClassName :: Name eqClassName = clsQual gHC_BASE FSLIT("Eq") eqClassKey eqName = methName gHC_BASE FSLIT("==") eqClassOpKey ordClassName = clsQual gHC_BASE FSLIT("Ord") ordClassKey @@ -474,58 +555,77 @@ geName = methName gHC_BASE FSLIT(">=") geClassOpKey functorClassName = clsQual gHC_BASE FSLIT("Functor") functorClassKey -- Class Monad +monadClassName, thenMName, bindMName, returnMName, failMName :: Name monadClassName = clsQual gHC_BASE FSLIT("Monad") monadClassKey thenMName = methName gHC_BASE FSLIT(">>") thenMClassOpKey bindMName = methName gHC_BASE FSLIT(">>=") bindMClassOpKey returnMName = methName gHC_BASE FSLIT("return") returnMClassOpKey failMName = methName gHC_BASE FSLIT("fail") failMClassOpKey +-- Functions for GHC extensions +groupWithName :: Name +groupWithName = varQual gHC_EXTS FSLIT("groupWith") groupWithIdKey + -- Random PrelBase functions +fromStringName, otherwiseIdName, foldrName, buildName, augmentName, + mapName, appendName, andName, orName, assertName, + breakpointName, breakpointCondName, breakpointAutoName, + opaqueTyConName :: Name +fromStringName = methName dATA_STRING FSLIT("fromString") fromStringClassOpKey otherwiseIdName = varQual gHC_BASE FSLIT("otherwise") otherwiseIdKey foldrName = varQual gHC_BASE FSLIT("foldr") foldrIdKey buildName = varQual gHC_BASE FSLIT("build") buildIdKey augmentName = varQual gHC_BASE FSLIT("augment") augmentIdKey +mapName = varQual gHC_BASE FSLIT("map") mapIdKey appendName = varQual gHC_BASE FSLIT("++") appendIdKey -andName = varQual gHC_BASE FSLIT("&&") andIdKey -orName = varQual gHC_BASE FSLIT("||") orIdKey +andName = varQual gHC_BASE FSLIT("&&") andIdKey +orName = varQual gHC_BASE FSLIT("||") orIdKey assertName = varQual gHC_BASE FSLIT("assert") assertIdKey breakpointName = varQual gHC_BASE FSLIT("breakpoint") breakpointIdKey breakpointCondName= varQual gHC_BASE FSLIT("breakpointCond") breakpointCondIdKey breakpointAutoName= varQual gHC_BASE FSLIT("breakpointAuto") breakpointAutoIdKey opaqueTyConName = tcQual gHC_BASE FSLIT("Opaque") opaqueTyConKey ++breakpointJumpName :: Name breakpointJumpName = mkInternalName breakpointJumpIdKey (mkOccNameFS varName FSLIT("breakpointJump")) - noSrcLoc + noSrcSpan +breakpointCondJumpName :: Name breakpointCondJumpName = mkInternalName breakpointCondJumpIdKey (mkOccNameFS varName FSLIT("breakpointCondJump")) - noSrcLoc + noSrcSpan +breakpointAutoJumpName :: Name breakpointAutoJumpName = mkInternalName breakpointAutoJumpIdKey (mkOccNameFS varName FSLIT("breakpointAutoJump")) - noSrcLoc + noSrcSpan -- PrelTup +fstName, sndName :: Name fstName = varQual dATA_TUP FSLIT("fst") fstIdKey sndName = varQual dATA_TUP FSLIT("snd") sndIdKey -- Module PrelNum +numClassName, fromIntegerName, minusName, negateName, plusIntegerName, + timesIntegerName, integerTyConName, smallIntegerName :: Name numClassName = clsQual gHC_NUM FSLIT("Num") numClassKey fromIntegerName = methName gHC_NUM FSLIT("fromInteger") fromIntegerClassOpKey minusName = methName gHC_NUM FSLIT("-") minusClassOpKey negateName = methName gHC_NUM FSLIT("negate") negateClassOpKey -plusIntegerName = varQual gHC_NUM FSLIT("plusInteger") plusIntegerIdKey -timesIntegerName = varQual gHC_NUM FSLIT("timesInteger") timesIntegerIdKey -integerTyConName = tcQual gHC_NUM FSLIT("Integer") integerTyConKey -smallIntegerDataConName = conName gHC_NUM FSLIT("S#") smallIntegerDataConKey -largeIntegerDataConName = conName gHC_NUM FSLIT("J#") largeIntegerDataConKey +plusIntegerName = varQual gHC_INTEGER FSLIT("plusInteger") plusIntegerIdKey +timesIntegerName = varQual gHC_INTEGER FSLIT("timesInteger") timesIntegerIdKey +integerTyConName = tcQual gHC_INTEGER FSLIT("Integer") integerTyConKey +smallIntegerName = varQual gHC_INTEGER FSLIT("smallInteger") smallIntegerIdKey -- PrelReal types and classes +rationalTyConName, ratioTyConName, ratioDataConName, realClassName, + integralClassName, realFracClassName, fractionalClassName, + fromRationalName :: Name rationalTyConName = tcQual gHC_REAL FSLIT("Rational") rationalTyConKey ratioTyConName = tcQual gHC_REAL FSLIT("Ratio") ratioTyConKey ratioDataConName = conName gHC_REAL FSLIT(":%") ratioDataConKey @@ -536,13 +636,18 @@ fractionalClassName = clsQual gHC_REAL FSLIT("Fractional") fractionalClassKey fromRationalName = methName gHC_REAL FSLIT("fromRational") fromRationalClassOpKey -- PrelFloat classes +floatingClassName, realFloatClassName :: Name floatingClassName = clsQual gHC_FLOAT FSLIT("Floating") floatingClassKey realFloatClassName = clsQual gHC_FLOAT FSLIT("RealFloat") realFloatClassKey -- Class Ix +ixClassName :: Name ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey -- Class Typeable +typeableClassName, typeable1ClassName, typeable2ClassName, + typeable3ClassName, typeable4ClassName, typeable5ClassName, + typeable6ClassName, typeable7ClassName :: Name typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey @@ -552,17 +657,22 @@ typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey +typeableClassNames :: [Name] typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName , typeable3ClassName, typeable4ClassName, typeable5ClassName , typeable6ClassName, typeable7ClassName ] -- Class Data +dataClassName :: Name dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey -- Error module +assertErrorName :: Name assertErrorName = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey -- Enum module (Enum, Bounded) +enumClassName, enumFromName, enumFromToName, enumFromThenName, + enumFromThenToName, boundedClassName :: Name enumClassName = clsQual gHC_ENUM FSLIT("Enum") enumClassKey enumFromName = methName gHC_ENUM FSLIT("enumFrom") enumFromClassOpKey enumFromToName = methName gHC_ENUM FSLIT("enumFromTo") enumFromToClassOpKey @@ -571,26 +681,34 @@ enumFromThenToName = methName gHC_ENUM FSLIT("enumFromThenTo") enumFromThenToCla boundedClassName = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey -- List functions +concatName, filterName, zipName :: Name concatName = varQual gHC_LIST FSLIT("concat") concatIdKey filterName = varQual gHC_LIST FSLIT("filter") filterIdKey zipName = varQual gHC_LIST FSLIT("zip") zipIdKey -- Class Show +showClassName :: Name showClassName = clsQual gHC_SHOW FSLIT("Show") showClassKey -- Class Read +readClassName :: Name readClassName = clsQual gHC_READ FSLIT("Read") readClassKey -- parallel array types and functions +enumFromToPName, enumFromThenToPName, nullPName, lengthPName, + singletonPName, replicatePName, mapPName, filterPName, + zipPName, crossMapPName, indexPName, toPName, bpermutePName, + bpermuteDftPName, indexOfPName :: Name enumFromToPName = varQual gHC_PARR FSLIT("enumFromToP") enumFromToPIdKey enumFromThenToPName= varQual gHC_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey nullPName = varQual gHC_PARR FSLIT("nullP") nullPIdKey lengthPName = varQual gHC_PARR FSLIT("lengthP") lengthPIdKey +singletonPName = varQual gHC_PARR FSLIT("singletonP") singletonPIdKey replicatePName = varQual gHC_PARR FSLIT("replicateP") replicatePIdKey mapPName = varQual gHC_PARR FSLIT("mapP") mapPIdKey filterPName = varQual gHC_PARR FSLIT("filterP") filterPIdKey zipPName = varQual gHC_PARR FSLIT("zipP") zipPIdKey -crossPName = varQual gHC_PARR FSLIT("crossP") crossPIdKey +crossMapPName = varQual gHC_PARR FSLIT("crossMapP") crossMapPIdKey indexPName = varQual gHC_PARR FSLIT("!:") indexPIdKey toPName = varQual gHC_PARR FSLIT("toP") toPIdKey bpermutePName = varQual gHC_PARR FSLIT("bpermuteP") bpermutePIdKey @@ -598,6 +716,8 @@ bpermuteDftPName = varQual gHC_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey indexOfPName = varQual gHC_PARR FSLIT("indexOfP") indexOfPIdKey -- IOBase things +ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName, + failIOName :: Name ioTyConName = tcQual gHC_IO_BASE FSLIT("IO") ioTyConKey ioDataConName = conName gHC_IO_BASE FSLIT("IO") ioDataConKey thenIOName = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey @@ -606,15 +726,19 @@ returnIOName = varQual gHC_IO_BASE FSLIT("returnIO") returnIOIdKey failIOName = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey -- IO things +printName :: Name printName = varQual sYSTEM_IO FSLIT("print") printIdKey -- Int, Word, and Addr things +int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name int8TyConName = tcQual gHC_INT FSLIT("Int8") int8TyConKey int16TyConName = tcQual gHC_INT FSLIT("Int16") int16TyConKey int32TyConName = tcQual gHC_INT FSLIT("Int32") int32TyConKey int64TyConName = tcQual gHC_INT FSLIT("Int64") int64TyConKey -- Word module +word8TyConName, word16TyConName, word32TyConName, word64TyConName, + wordTyConName, wordDataConName :: Name word8TyConName = tcQual gHC_WORD FSLIT("Word8") word8TyConKey word16TyConName = tcQual gHC_WORD FSLIT("Word16") word16TyConKey word32TyConName = tcQual gHC_WORD FSLIT("Word32") word32TyConKey @@ -623,37 +747,48 @@ wordTyConName = tcQual gHC_WORD FSLIT("Word") wordTyConKey wordDataConName = conName gHC_WORD FSLIT("W#") wordDataConKey -- PrelPtr module +ptrTyConName, funPtrTyConName :: Name ptrTyConName = tcQual gHC_PTR FSLIT("Ptr") ptrTyConKey funPtrTyConName = tcQual gHC_PTR FSLIT("FunPtr") funPtrTyConKey -- Foreign objects and weak pointers +stablePtrTyConName, newStablePtrName :: Name stablePtrTyConName = tcQual gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey newStablePtrName = varQual gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey -- PrelST module +runSTRepName :: Name runSTRepName = varQual gHC_ST FSLIT("runSTRep") runSTRepIdKey -- Recursive-do notation +monadFixClassName, mfixName :: Name monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey mfixName = methName mONAD_FIX FSLIT("mfix") mfixIdKey -- Arrow notation +arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name arrAName = varQual aRROW FSLIT("arr") arrAIdKey -composeAName = varQual aRROW FSLIT(">>>") composeAIdKey +composeAName = varQual gHC_DESUGAR 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 -- Other classes, needed for type defaulting +monadPlusClassName, randomClassName, randomGenClassName, + isStringClassName :: Name monadPlusClassName = clsQual mONAD FSLIT("MonadPlus") monadPlusClassKey randomClassName = clsQual rANDOM FSLIT("Random") randomClassKey randomGenClassName = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey +isStringClassName = clsQual dATA_STRING FSLIT("IsString") isStringClassKey -- dotnet interop +objectTyConName :: Name 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, marshalObjectName, marshalStringName, + unmarshalStringName, checkDotnetResName :: Name unmarshalObjectName = varQual dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey marshalObjectName = varQual dOTNET FSLIT("marshalObject") marshalObjectIdKey marshalStringName = varQual dOTNET FSLIT("marshalString") marshalStringIdKey @@ -670,20 +805,22 @@ checkDotnetResName = varQual dOTNET FSLIT("checkResult") checkDotnetResNam All these are original names; hence mkOrig \begin{code} +varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name varQual = mk_known_key_name varName tcQual = mk_known_key_name tcName clsQual = mk_known_key_name clsName -mk_known_key_name space mod str uniq - = mkExternalName uniq mod (mkOccNameFS space str) noSrcLoc +mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name +mk_known_key_name space modu str unique + = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan conName :: Module -> FastString -> Unique -> Name -conName mod occ uniq - = mkExternalName uniq mod (mkOccNameFS dataName occ) noSrcLoc +conName modu occ unique + = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan methName :: Module -> FastString -> Unique -> Name -methName mod occ uniq - = mkExternalName uniq mod (mkVarOccFS occ) noSrcLoc +methName modu occ unique + = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan \end{code} %************************************************************************ @@ -694,6 +831,10 @@ methName mod occ uniq --MetaHaskell extension hand allocate keys here \begin{code} +boundedClassKey, enumClassKey, eqClassKey, floatingClassKey, + fractionalClassKey, integralClassKey, monadClassKey, dataClassKey, + functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey, + realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique boundedClassKey = mkPreludeClassUnique 1 enumClassKey = mkPreludeClassUnique 2 eqClassKey = mkPreludeClassUnique 3 @@ -712,6 +853,9 @@ realFracClassKey = mkPreludeClassUnique 16 showClassKey = mkPreludeClassUnique 17 ixClassKey = mkPreludeClassUnique 18 +typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey, + typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey + :: Unique typeableClassKey = mkPreludeClassUnique 20 typeable1ClassKey = mkPreludeClassUnique 21 typeable2ClassKey = mkPreludeClassUnique 22 @@ -721,11 +865,16 @@ typeable5ClassKey = mkPreludeClassUnique 25 typeable6ClassKey = mkPreludeClassUnique 26 typeable7ClassKey = mkPreludeClassUnique 27 +monadFixClassKey :: Unique monadFixClassKey = mkPreludeClassUnique 28 +monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique monadPlusClassKey = mkPreludeClassUnique 30 randomClassKey = mkPreludeClassUnique 31 randomGenClassKey = mkPreludeClassUnique 32 + +isStringClassKey :: Unique +isStringClassKey = mkPreludeClassUnique 33 \end{code} %************************************************************************ @@ -735,6 +884,15 @@ randomGenClassKey = mkPreludeClassUnique 32 %************************************************************************ \begin{code} +addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey, + charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey, + floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey, + intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey, + int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey, + listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey, + mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, + orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey, + realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique addrPrimTyConKey = mkPreludeTyConUnique 1 arrayPrimTyConKey = mkPreludeTyConUnique 3 boolTyConKey = mkPreludeTyConUnique 4 @@ -768,9 +926,17 @@ realWorldTyConKey = mkPreludeTyConUnique 34 stablePtrPrimTyConKey = mkPreludeTyConUnique 35 stablePtrTyConKey = mkPreludeTyConUnique 36 +anyPrimTyConKey, anyPrimTyCon1Key :: Unique anyPrimTyConKey = mkPreludeTyConUnique 37 anyPrimTyCon1Key = mkPreludeTyConUnique 38 +statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey, + mutVarPrimTyConKey, ioTyConKey, + wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey, + word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey, + liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey, + typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey, + funPtrTyConKey, tVarPrimTyConKey :: Unique statePrimTyConKey = mkPreludeTyConUnique 50 stableNamePrimTyConKey = mkPreludeTyConUnique 51 stableNameTyConKey = mkPreludeTyConUnique 52 @@ -797,23 +963,30 @@ funPtrTyConKey = mkPreludeTyConUnique 75 tVarPrimTyConKey = mkPreludeTyConUnique 76 -- Generic Type Constructors +crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique crossTyConKey = mkPreludeTyConUnique 79 plusTyConKey = mkPreludeTyConUnique 80 genUnitTyConKey = mkPreludeTyConUnique 81 -- Parallel array type constructor +parrTyConKey :: Unique parrTyConKey = mkPreludeTyConUnique 82 -- dotnet interop +objectTyConKey :: Unique objectTyConKey = mkPreludeTyConUnique 83 +eitherTyConKey :: Unique eitherTyConKey = mkPreludeTyConUnique 84 -- Super Kinds constructors +tySuperKindTyConKey, coSuperKindTyConKey :: Unique tySuperKindTyConKey = mkPreludeTyConUnique 85 coSuperKindTyConKey = mkPreludeTyConUnique 86 -- Kind constructors +liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey, + ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique liftedTypeKindTyConKey = mkPreludeTyConUnique 87 openTypeKindTyConKey = mkPreludeTyConUnique 88 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89 @@ -821,6 +994,9 @@ ubxTupleKindTyConKey = mkPreludeTyConUnique 90 argTypeKindTyConKey = mkPreludeTyConUnique 91 -- Coercion constructors +symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey, + rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey + :: Unique symCoercionTyConKey = mkPreludeTyConUnique 93 transCoercionTyConKey = mkPreludeTyConUnique 94 leftCoercionTyConKey = mkPreludeTyConUnique 95 @@ -828,12 +1004,22 @@ rightCoercionTyConKey = mkPreludeTyConUnique 96 instCoercionTyConKey = mkPreludeTyConUnique 97 unsafeCoercionTyConKey = mkPreludeTyConUnique 98 -opaqueTyConKey = mkPreludeTyConUnique 103 +unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey, + opaqueTyConKey :: Unique +unknownTyConKey = mkPreludeTyConUnique 99 +unknown1TyConKey = mkPreludeTyConUnique 130 +unknown2TyConKey = mkPreludeTyConUnique 131 +unknown3TyConKey = mkPreludeTyConUnique 132 +opaqueTyConKey = mkPreludeTyConUnique 133 + +stringTyConKey :: Unique +stringTyConKey = mkPreludeTyConUnique 134 ---------------- Template Haskell ------------------- -- USES TyConUniques 100-129 ----------------------------------------------------- +unitTyConKey :: Unique unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} @@ -844,14 +1030,16 @@ unitTyConKey = mkTupleTyConUnique Boxed 0 %************************************************************************ \begin{code} +charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey, + floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey, + stableNameDataConKey, trueDataConKey, wordDataConKey, + ioDataConKey :: Unique charDataConKey = mkPreludeDataConUnique 1 consDataConKey = mkPreludeDataConUnique 2 doubleDataConKey = mkPreludeDataConUnique 3 falseDataConKey = mkPreludeDataConUnique 4 floatDataConKey = mkPreludeDataConUnique 5 intDataConKey = mkPreludeDataConUnique 6 -smallIntegerDataConKey = mkPreludeDataConUnique 7 -largeIntegerDataConKey = mkPreludeDataConUnique 8 nilDataConKey = mkPreludeDataConUnique 11 ratioDataConKey = mkPreludeDataConUnique 12 stableNameDataConKey = mkPreludeDataConUnique 14 @@ -860,14 +1048,17 @@ wordDataConKey = mkPreludeDataConUnique 16 ioDataConKey = mkPreludeDataConUnique 17 -- Generic data constructors +crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique crossDataConKey = mkPreludeDataConUnique 20 inlDataConKey = mkPreludeDataConUnique 21 inrDataConKey = mkPreludeDataConUnique 22 genUnitDataConKey = mkPreludeDataConUnique 23 -- Data constructor for parallel arrays +parrDataConKey :: Unique parrDataConKey = mkPreludeDataConUnique 24 +leftDataConKey, rightDataConKey :: Unique leftDataConKey = mkPreludeDataConUnique 25 rightDataConKey = mkPreludeDataConUnique 26 \end{code} @@ -879,6 +1070,17 @@ rightDataConKey = mkPreludeDataConUnique 26 %************************************************************************ \begin{code} +absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey, + foldlIdKey, foldrIdKey, recSelErrorIdKey, + integerMinusOneIdKey, integerPlusOneIdKey, + integerPlusTwoIdKey, integerZeroIdKey, + int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey, + noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey, + runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey, + realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey, + traceIdKey, + unpackCStringUtf8IdKey, unpackCStringAppendIdKey, + unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique absentErrorIdKey = mkPreludeMiscIdUnique 1 augmentIdKey = mkPreludeMiscIdUnique 3 appendIdKey = mkPreludeMiscIdUnique 4 @@ -910,6 +1112,11 @@ unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30 unpackCStringIdKey = mkPreludeMiscIdUnique 31 +unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey, + returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey, + smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey, + printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey, + fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique unsafeCoerceIdKey = mkPreludeMiscIdUnique 32 concatIdKey = mkPreludeMiscIdUnique 33 filterIdKey = mkPreludeMiscIdUnique 34 @@ -918,6 +1125,7 @@ bindIOIdKey = mkPreludeMiscIdUnique 36 returnIOIdKey = mkPreludeMiscIdUnique 37 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 newStablePtrIdKey = mkPreludeMiscIdUnique 39 +smallIntegerIdKey = mkPreludeMiscIdUnique 40 plusIntegerIdKey = mkPreludeMiscIdUnique 41 timesIntegerIdKey = mkPreludeMiscIdUnique 42 printIdKey = mkPreludeMiscIdUnique 43 @@ -930,15 +1138,20 @@ otherwiseIdKey = mkPreludeMiscIdUnique 51 assertIdKey = mkPreludeMiscIdUnique 53 runSTRepIdKey = mkPreludeMiscIdUnique 54 +rootMainKey, runMainKey :: Unique rootMainKey = mkPreludeMiscIdUnique 55 runMainKey = mkPreludeMiscIdUnique 56 +andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique andIdKey = mkPreludeMiscIdUnique 57 orIdKey = mkPreludeMiscIdUnique 58 thenIOIdKey = mkPreludeMiscIdUnique 59 lazyIdKey = mkPreludeMiscIdUnique 60 assertErrorIdKey = mkPreludeMiscIdUnique 61 +breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey, + breakpointJumpIdKey, breakpointCondJumpIdKey, + breakpointAutoJumpIdKey :: Unique breakpointIdKey = mkPreludeMiscIdUnique 62 breakpointCondIdKey = mkPreludeMiscIdUnique 63 breakpointAutoIdKey = mkPreludeMiscIdUnique 64 @@ -946,16 +1159,26 @@ breakpointJumpIdKey = mkPreludeMiscIdUnique 65 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67 +inlineIdKey :: Unique inlineIdKey = mkPreludeMiscIdUnique 68 +mapIdKey, groupWithIdKey :: Unique +mapIdKey = mkPreludeMiscIdUnique 69 +groupWithIdKey = mkPreludeMiscIdUnique 70 + -- Parallel array functions +singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey, + filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey, + enumFromToPIdKey, enumFromThenToPIdKey, + bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique +singletonPIdKey = mkPreludeMiscIdUnique 79 nullPIdKey = mkPreludeMiscIdUnique 80 lengthPIdKey = mkPreludeMiscIdUnique 81 replicatePIdKey = mkPreludeMiscIdUnique 82 mapPIdKey = mkPreludeMiscIdUnique 83 filterPIdKey = mkPreludeMiscIdUnique 84 zipPIdKey = mkPreludeMiscIdUnique 85 -crossPIdKey = mkPreludeMiscIdUnique 86 +crossMapPIdKey = mkPreludeMiscIdUnique 86 indexPIdKey = mkPreludeMiscIdUnique 87 toPIdKey = mkPreludeMiscIdUnique 88 enumFromToPIdKey = mkPreludeMiscIdUnique 89 @@ -965,6 +1188,8 @@ bpermuteDftPIdKey = mkPreludeMiscIdUnique 92 indexOfPIdKey = mkPreludeMiscIdUnique 93 -- dotnet interop +unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey, + unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique unmarshalObjectIdKey = mkPreludeMiscIdUnique 94 marshalObjectIdKey = mkPreludeMiscIdUnique 95 marshalStringIdKey = mkPreludeMiscIdUnique 96 @@ -979,8 +1204,14 @@ during type checking. \begin{code} -- Just a place holder for unbound variables produced by the renamer: +unboundKey :: Unique unboundKey = mkPreludeMiscIdUnique 101 +fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey, + enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey, + enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey, + failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey + :: Unique fromIntegerClassOpKey = mkPreludeMiscIdUnique 102 minusClassOpKey = mkPreludeMiscIdUnique 103 fromRationalClassOpKey = mkPreludeMiscIdUnique 104 @@ -997,9 +1228,12 @@ thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>) returnMClassOpKey = mkPreludeMiscIdUnique 117 -- Recursive do notation +mfixIdKey :: Unique mfixIdKey = mkPreludeMiscIdUnique 118 -- Arrow notation +arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey, + loopAIdKey :: Unique arrAIdKey = mkPreludeMiscIdUnique 119 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>> firstAIdKey = mkPreludeMiscIdUnique 121 @@ -1007,6 +1241,9 @@ appAIdKey = mkPreludeMiscIdUnique 122 choiceAIdKey = mkPreludeMiscIdUnique 123 -- ||| loopAIdKey = mkPreludeMiscIdUnique 124 +fromStringClassOpKey :: Unique +fromStringClassOpKey = mkPreludeMiscIdUnique 125 + ---------------- Template Haskell ------------------- -- USES IdUniques 200-399 ----------------------------------------------------- @@ -1020,6 +1257,7 @@ loopAIdKey = mkPreludeMiscIdUnique 124 %************************************************************************ \begin{code} +numericTyKeys :: [Unique] numericTyKeys = [ wordTyConKey , intTyConKey @@ -1041,6 +1279,7 @@ even though every numeric class has these two as a superclass, because the list of ambiguous dictionaries hasn't been simplified. \begin{code} +numericClassKeys :: [Unique] numericClassKeys = [ numClassKey , realClassKey @@ -1048,6 +1287,7 @@ numericClassKeys = ] ++ fractionalClassKeys +fractionalClassKeys :: [Unique] fractionalClassKeys = [ fractionalClassKey , floatingClassKey @@ -1057,22 +1297,27 @@ fractionalClassKeys = -- the strictness analyser needs to know about numeric types -- (see SaAbsInt.lhs) +needsDataDeclCtxtClassKeys :: [Unique] needsDataDeclCtxtClassKeys = -- see comments in TcDeriv [ readClassKey ] -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4), -- and are: "classes defined in the Prelude or a standard library" +standardClassKeys :: [Unique] standardClassKeys = derivableClassKeys ++ numericClassKeys ++ [randomClassKey, randomGenClassKey, functorClassKey, - monadClassKey, monadPlusClassKey] + monadClassKey, monadPlusClassKey, + isStringClassKey + ] \end{code} @derivableClassKeys@ is also used in checking \tr{deriving} constructs (@TcDeriv@). \begin{code} +derivableClassKeys :: [Unique] derivableClassKeys = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey, boundedClassKey, showClassKey, readClassKey ]