%
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
-\section[PrelNames]{Definitions of prelude modules}
+\section[PrelNames]{Definitions of prelude modules and names}
-The strings identify built-in prelude modules. They are
-defined here so as to avod
-[oh dear, looks like the recursive module monster caught up with
- and gobbled whoever was writing the above :-) -- SOF ]
+Nota Bene: all Names defined in here should come from the base package
+
+* ModuleNames for prelude modules,
+ e.g. pREL_BASE_Name :: ModuleName
+
+* Modules for prelude modules
+ e.g. pREL_Base :: Module
+
+* Uniques for Ids, DataCons, TyCons and Classes that the compiler
+ "knows about" in some way
+ e.g. intTyConKey :: Unique
+ minusClassOpKey :: Unique
+
+* Names for Ids, DataCons, TyCons and Classes that the compiler
+ "knows about" in some way
+ e.g. intTyConName :: Name
+ minusName :: Name
+ One of these Names contains
+ (a) the module and occurrence name of the thing
+ (b) its Unique
+ The may way the compiler "knows about" one of these things is
+ where the type checker or desugarer needs to look it up. For
+ example, when desugaring list comprehensions the desugarer
+ needs to conjure up 'foldr'. It does this by looking up
+ foldrName in the environment.
+
+* RdrNames for Ids, DataCons etc that the compiler may emit into
+ generated code (e.g. for deriving). It's not necessary to know
+ the uniques for these guys, only their names
+
\begin{code}
module PrelNames (
Unique, Uniquable(..), hasKey, -- Re-exported for convenience
-----------------------------------------------------------
- module PrelNames, -- A huge bunch of (a) RdrNames, e.g. intTyCon_RDR
- -- (b) Uniques e.g. intTyConKey
+ 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,
- mkTupNameStr, mkTupConRdrName,
-
- SyntaxMap, vanillaSyntaxMap, SyntaxList, syntaxList,
-
- ------------------------------------------------------------
- -- Goups of classes and types
- needsDataDeclCtxtClassKeys, cCallishClassKeys, noDictClassKeys,
- fractionalClassKeys, numericClassKeys, standardClassKeys,
- derivingOccurrences, -- For a given class C, this tells what other
- 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 )
-import OccName ( NameSpace, UserFS, varName, dataName, tcName, clsName,
- mkKindOccFS, mkOccFS
- )
-import RdrName ( RdrName, mkOrig, mkUnqual )
-import UniqFM
+import Module ( Module, mkModule )
+import OccName ( dataName, tcName, clsName, varName, mkOccNameFS,
+ mkVarOccFS )
+import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
import Unique ( Unique, Uniquable(..), hasKey,
mkPreludeMiscIdUnique, mkPreludeDataConUnique,
- mkPreludeTyConUnique, mkPreludeClassUnique
+ mkPreludeTyConUnique, mkPreludeClassUnique,
+ mkTupleTyConUnique
)
import BasicTypes ( Boxity(..), Arity )
-import UniqFM ( UniqFM, listToUFM )
-import Name ( Name, mkLocalName, mkKnownKeyGlobal, nameRdrName )
-import RdrName ( rdrNameOcc )
-import SrcLoc ( builtinSrcLoc, noSrcLoc )
-import Util ( nOfThem )
-import Panic ( panic )
+import Name ( Name, mkInternalName, mkExternalName, nameModule )
+import SrcLoc ( noSrcLoc )
+import FastString
\end{code}
This *local* name is used by the interactive stuff
\begin{code}
-itName = mkLocalName itIdKey (mkOccFS varName SLIT("it")) noSrcLoc
+itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcLoc
\end{code}
\begin{code}
-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
-- during compiler debugging.
mkUnboundName :: RdrName -> Name
-mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) builtinSrcLoc
+mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcLoc
isUnboundName :: Name -> Bool
isUnboundName name = name `hasKey` unboundKey
wired in ones are defined in TysWiredIn etc.
\begin{code}
-knownKeyNames :: [Name]
-knownKeyNames
- = [
- -- Type constructors (synonyms especially)
- ioTyConName,
- mainName,
+basicKnownKeyNames :: [Name]
+basicKnownKeyNames
+ = genericTyConNames
+ ++ typeableClassNames
+ ++ [ -- Type constructors (synonyms especially)
+ ioTyConName, ioDataConName,
+ runMainIOName,
orderingTyConName,
rationalTyConName,
ratioDataConName,
ratioTyConName,
byteArrayTyConName,
mutableByteArrayTyConName,
- foreignObjTyConName,
- foreignPtrTyConName,
- bcoPrimTyConName,
- stablePtrTyConName,
- stablePtrDataConName,
+ integerTyConName, smallIntegerDataConName, largeIntegerDataConName,
-- Classes. *Must* include:
-- classes that are grabbed by key (e.g., eqClassKey)
numClassName, -- mentioned, numeric
enumClassName, -- derivable
monadClassName,
- monadPlusClassName,
functorClassName,
- showClassName, -- derivable
realClassName, -- numeric
integralClassName, -- numeric
fractionalClassName, -- numeric
floatingClassName, -- numeric
realFracClassName, -- numeric
realFloatClassName, -- numeric
- readClassName, -- derivable
- ixClassName, -- derivable (but it isn't Prelude.Ix; hmmm)
- cCallableClassName, -- mentioned, ccallish
- cReturnableClassName, -- mentioned, ccallish
-
- -- ClassOps
- fromIntegerName,
- negateName,
- geName,
- minusName,
- enumFromName,
- enumFromThenName,
- enumFromToName,
- enumFromThenToName,
- fromEnumName,
- toEnumName,
- eqName,
- thenMName,
- returnMName,
- failMName,
- fromRationalName,
-
- deRefStablePtrName,
+ dataClassName,
+
+ -- Numeric stuff
+ negateName, minusName,
+ fromRationalName, fromIntegerName,
+ geName, eqName,
+
+ -- Enum stuff
+ enumFromName, enumFromThenName,
+ enumFromThenToName, enumFromToName,
+ enumFromToPName, enumFromThenToPName,
+
+ -- Monad stuff
+ thenIOName, bindIOName, returnIOName, failIOName,
+ failMName, bindMName, thenMName, returnMName,
+
+ -- MonadRec stuff
+ mfixName,
+
+ -- Arrow stuff
+ arrAName, composeAName, firstAName,
+ appAName, choiceAName, loopAName,
+
+ -- Ix stuff
+ ixClassName,
+
+ -- Show stuff
+ showClassName,
+
+ -- Read stuff
+ readClassName,
+
+ -- Stable pointers
newStablePtrName,
- bindIOName,
- returnIOName,
- failIOName,
-- Strings and lists
- mapName,
- appendName,
- unpackCStringName,
- unpackCStringAppendName,
- unpackCStringFoldrName,
- unpackCStringUtf8Name,
+ unpackCStringName, unpackCStringAppendName,
+ unpackCStringFoldrName, unpackCStringUtf8Name,
-- List operations
- concatName,
- filterName,
- zipName,
- foldrName,
- buildName,
- augmentName,
+ concatName, filterName,
+ zipName, foldrName, buildName, augmentName, appendName,
+
+ -- Parallel array operations
+ nullPName, lengthPName, replicatePName, mapPName,
+ filterPName, zipPName, crossPName, indexPName,
+ toPName, bpermutePName, bpermuteDftPName, indexOfPName,
-- FFI primitive types that are not wired-in.
- int8TyConName,
- int16TyConName,
- int32TyConName,
- int64TyConName,
- word8TyConName,
- word16TyConName,
- word32TyConName,
- word64TyConName,
+ stablePtrTyConName, ptrTyConName, funPtrTyConName, addrTyConName,
+ int8TyConName, int16TyConName, int32TyConName, int64TyConName,
+ wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
-- Others
- unsafeCoerceName,
- otherwiseIdName,
- plusIntegerName,
- timesIntegerName,
- eqStringName,
- assertName,
- runSTRepName,
- printName
+ otherwiseIdName,
+ plusIntegerName, timesIntegerName,
+ eqStringName, assertName, assertErrorName, runSTRepName,
+ printName, fstName, sndName,
+
+ -- MonadFix
+ monadFixClassName, mfixName,
+
+ -- Splittable class
+ splittableClassName, splitName,
+
+ -- Other classes
+ randomClassName, randomGenClassName, monadPlusClassName,
+
+ -- Booleans
+ andName, orName
+
+ -- The Either type
+ , eitherTyConName, leftDataConName, rightDataConName
+
+ -- dotnet interop
+ , objectTyConName, marshalObjectName, unmarshalObjectName
+ , marshalStringName, unmarshalStringName, checkDotnetResName
]
+
+genericTyConNames :: [Name]
+genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
\end{code}
%* *
%************************************************************************
+
+--MetaHaskell Extension Add a new module here
\begin{code}
-pRELUDE_Name = mkModuleName "Prelude"
-pREL_GHC_Name = mkModuleName "PrelGHC" -- Primitive types and values
-pREL_BASE_Name = mkModuleName "PrelBase"
-pREL_ENUM_Name = mkModuleName "PrelEnum"
-pREL_SHOW_Name = mkModuleName "PrelShow"
-pREL_READ_Name = mkModuleName "PrelRead"
-pREL_NUM_Name = mkModuleName "PrelNum"
-pREL_LIST_Name = mkModuleName "PrelList"
-pREL_TUP_Name = mkModuleName "PrelTup"
-pREL_PACK_Name = mkModuleName "PrelPack"
-pREL_CONC_Name = mkModuleName "PrelConc"
-pREL_IO_BASE_Name = mkModuleName "PrelIOBase"
-pREL_IO_Name = mkModuleName "PrelIO"
-pREL_ST_Name = mkModuleName "PrelST"
-pREL_ARR_Name = mkModuleName "PrelArr"
-pREL_BYTEARR_Name = mkModuleName "PrelByteArr"
-pREL_FOREIGN_Name = mkModuleName "PrelForeign"
-pREL_STABLE_Name = mkModuleName "PrelStable"
-pREL_ADDR_Name = mkModuleName "PrelAddr"
-pREL_PTR_Name = mkModuleName "PrelPtr"
-pREL_ERR_Name = mkModuleName "PrelErr"
-pREL_REAL_Name = mkModuleName "PrelReal"
-pREL_FLOAT_Name = mkModuleName "PrelFloat"
-
-pREL_MAIN_Name = mkModuleName "PrelMain"
-mAIN_Name = mkModuleName "Main"
-pREL_INT_Name = mkModuleName "PrelInt"
-pREL_WORD_Name = mkModuleName "PrelWord"
-
-fOREIGNOBJ_Name = mkModuleName "ForeignObj"
-aDDR_Name = mkModuleName "Addr"
-
-pREL_GHC = mkPrelModule pREL_GHC_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
-
-iNTERACTIVE = mkHomeModule (mkModuleName "$Interactive")
+pRELUDE = mkModule "Prelude"
+gHC_PRIM = mkModule "GHC.Prim" -- Primitive types and values
+pREL_BASE = mkModule "GHC.Base"
+pREL_ENUM = mkModule "GHC.Enum"
+pREL_SHOW = mkModule "GHC.Show"
+pREL_READ = mkModule "GHC.Read"
+pREL_NUM = mkModule "GHC.Num"
+pREL_LIST = mkModule "GHC.List"
+pREL_PARR = mkModule "GHC.PArr"
+pREL_TUP = mkModule "Data.Tuple"
+pREL_EITHER = mkModule "Data.Either"
+pREL_PACK = mkModule "GHC.Pack"
+pREL_CONC = mkModule "GHC.Conc"
+pREL_IO_BASE = mkModule "GHC.IOBase"
+pREL_ST = mkModule "GHC.ST"
+pREL_ARR = mkModule "GHC.Arr"
+pREL_BYTEARR = mkModule "PrelByteArr"
+pREL_STABLE = mkModule "GHC.Stable"
+pREL_ADDR = mkModule "GHC.Addr"
+pREL_PTR = mkModule "GHC.Ptr"
+pREL_ERR = mkModule "GHC.Err"
+pREL_REAL = mkModule "GHC.Real"
+pREL_FLOAT = mkModule "GHC.Float"
+pREL_TOP_HANDLER= mkModule "GHC.TopHandler"
+sYSTEM_IO = mkModule "System.IO"
+dYNAMIC = mkModule "Data.Dynamic"
+tYPEABLE = mkModule "Data.Typeable"
+gENERICS = mkModule "Data.Generics.Basics"
+dOTNET = mkModule "GHC.Dotnet"
+
+rEAD_PREC = mkModule "Text.ParserCombinators.ReadPrec"
+lEX = mkModule "Text.Read.Lex"
+
+mAIN = mkModule "Main"
+pREL_INT = mkModule "GHC.Int"
+pREL_WORD = mkModule "GHC.Word"
+mONAD = mkModule "Control.Monad"
+mONAD_FIX = mkModule "Control.Monad.Fix"
+aRROW = mkModule "Control.Arrow"
+aDDR = mkModule "Addr"
+rANDOM = mkModule "System.Random"
+
+gLA_EXTS = mkModule "GHC.Exts"
+rOOT_MAIN = mkModule ":Main" -- Root module for initialisation
+ -- The ':xxx' makes a module 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 = mkModule ":Interactive"
+thFAKE = mkModule ":THFake"
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS)
-
-mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()"))
-mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???"
-mkTupNameStr Boxed 2 = (pREL_TUP_Name, _PK_ "(,)") -- not strictly necessary
-mkTupNameStr Boxed 3 = (pREL_TUP_Name, _PK_ "(,,)") -- ditto
-mkTupNameStr Boxed 4 = (pREL_TUP_Name, _PK_ "(,,,)") -- ditto
-mkTupNameStr Boxed n = (pREL_TUP_Name, _PK_ ("(" ++ nOfThem (n-1) ',' ++ ")"))
-
-mkTupNameStr Unboxed 0 = panic "Name.mkUbxTupNameStr: 0 ???"
-mkTupNameStr Unboxed 1 = (pREL_GHC_Name, _PK_ "(# #)") -- 1 and 0 both make sense!!!
-mkTupNameStr Unboxed 2 = (pREL_GHC_Name, _PK_ "(#,#)")
-mkTupNameStr Unboxed 3 = (pREL_GHC_Name, _PK_ "(#,,#)")
-mkTupNameStr Unboxed 4 = (pREL_GHC_Name, _PK_ "(#,,,#)")
-mkTupNameStr Unboxed n = (pREL_GHC_Name, _PK_ ("(#" ++ nOfThem (n-1) ',' ++ "#)"))
-
-mkTupConRdrName :: NameSpace -> Boxity -> Arity -> RdrName
-mkTupConRdrName space boxity arity = case mkTupNameStr boxity arity of
- (mod, occ) -> mkOrig space mod occ
+mkTupleModule :: Boxity -> Arity -> Module
+mkTupleModule Boxed 0 = pREL_BASE
+mkTupleModule Boxed _ = pREL_TUP
+mkTupleModule Unboxed _ = gHC_PRIM
\end{code}
%************************************************************************
%* *
-\subsection{Unqualified RdrNames}
+ RdrNames
%* *
%************************************************************************
\begin{code}
-main_RDR_Unqual :: RdrName
-main_RDR_Unqual = mkUnqual varName SLIT("main")
--- Don't get a RdrName from PrelNames.mainName, because nameRdrName
--- gets an Orig RdrName, and we want a Qual or Unqual one. An Unqual
--- one will do fine.
-\end{code}
+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
+
+eq_RDR = nameRdrName eqName
+ge_RDR = nameRdrName geName
+ne_RDR = varQual_RDR pREL_BASE FSLIT("/=")
+le_RDR = varQual_RDR pREL_BASE FSLIT("<=")
+gt_RDR = varQual_RDR pREL_BASE FSLIT(">")
+compare_RDR = varQual_RDR pREL_BASE FSLIT("compare")
+ltTag_RDR = dataQual_RDR pREL_BASE FSLIT("LT")
+eqTag_RDR = dataQual_RDR pREL_BASE FSLIT("EQ")
+gtTag_RDR = dataQual_RDR pREL_BASE FSLIT("GT")
+
+eqClass_RDR = nameRdrName eqClassName
+numClass_RDR = nameRdrName numClassName
+ordClass_RDR = nameRdrName ordClassName
+enumClass_RDR = nameRdrName enumClassName
+monadClass_RDR = nameRdrName monadClassName
+
+map_RDR = varQual_RDR pREL_BASE FSLIT("map")
+append_RDR = varQual_RDR pREL_BASE FSLIT("++")
+
+foldr_RDR = nameRdrName foldrName
+build_RDR = nameRdrName buildName
+returnM_RDR = nameRdrName returnMName
+bindM_RDR = nameRdrName bindMName
+failM_RDR = nameRdrName failMName
+
+and_RDR = nameRdrName andName
+left_RDR = nameRdrName leftDataConName
+right_RDR = nameRdrName rightDataConName
+
+fromEnum_RDR = varQual_RDR pREL_ENUM FSLIT("fromEnum")
+toEnum_RDR = varQual_RDR pREL_ENUM FSLIT("toEnum")
+
+enumFrom_RDR = nameRdrName enumFromName
+enumFromTo_RDR = nameRdrName enumFromToName
+enumFromThen_RDR = nameRdrName enumFromThenName
+enumFromThenTo_RDR = nameRdrName enumFromThenToName
+
+ratioDataCon_RDR = nameRdrName ratioDataConName
+plusInteger_RDR = nameRdrName plusIntegerName
+timesInteger_RDR = nameRdrName timesIntegerName
+
+ioDataCon_RDR = nameRdrName ioDataConName
+
+eqString_RDR = nameRdrName eqStringName
+unpackCString_RDR = nameRdrName unpackCStringName
+unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
+unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
+
+newStablePtr_RDR = nameRdrName newStablePtrName
+addrDataCon_RDR = dataQual_RDR aDDR FSLIT("A#")
+wordDataCon_RDR = dataQual_RDR pREL_WORD FSLIT("W#")
+
+bindIO_RDR = nameRdrName bindIOName
+returnIO_RDR = nameRdrName returnIOName
+
+fromInteger_RDR = nameRdrName fromIntegerName
+fromRational_RDR = nameRdrName fromRationalName
+minus_RDR = nameRdrName minusName
+times_RDR = varQual_RDR pREL_NUM FSLIT("*")
+plus_RDR = varQual_RDR pREL_NUM FSLIT("+")
+
+compose_RDR = varQual_RDR pREL_BASE FSLIT(".")
+
+not_RDR = varQual_RDR pREL_BASE FSLIT("not")
+getTag_RDR = varQual_RDR pREL_BASE FSLIT("getTag")
+succ_RDR = varQual_RDR pREL_ENUM FSLIT("succ")
+pred_RDR = varQual_RDR pREL_ENUM FSLIT("pred")
+minBound_RDR = varQual_RDR pREL_ENUM FSLIT("minBound")
+maxBound_RDR = varQual_RDR pREL_ENUM FSLIT("maxBound")
+range_RDR = varQual_RDR pREL_ARR FSLIT("range")
+inRange_RDR = varQual_RDR pREL_ARR FSLIT("inRange")
+index_RDR = varQual_RDR pREL_ARR FSLIT("index")
+unsafeIndex_RDR = varQual_RDR pREL_ARR FSLIT("unsafeIndex")
+unsafeRangeSize_RDR = varQual_RDR pREL_ARR FSLIT("unsafeRangeSize")
+
+readList_RDR = varQual_RDR pREL_READ FSLIT("readList")
+readListDefault_RDR = varQual_RDR pREL_READ FSLIT("readListDefault")
+readListPrec_RDR = varQual_RDR pREL_READ FSLIT("readListPrec")
+readListPrecDefault_RDR = varQual_RDR pREL_READ FSLIT("readListPrecDefault")
+readPrec_RDR = varQual_RDR pREL_READ FSLIT("readPrec")
+parens_RDR = varQual_RDR pREL_READ FSLIT("parens")
+choose_RDR = varQual_RDR pREL_READ FSLIT("choose")
+lexP_RDR = varQual_RDR pREL_READ FSLIT("lexP")
+
+punc_RDR = dataQual_RDR lEX FSLIT("Punc")
+ident_RDR = dataQual_RDR lEX FSLIT("Ident")
+symbol_RDR = dataQual_RDR lEX FSLIT("Symbol")
+
+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 = varQual_RDR pREL_SHOW FSLIT("showList")
+showList___RDR = varQual_RDR pREL_SHOW FSLIT("showList__")
+showsPrec_RDR = varQual_RDR pREL_SHOW FSLIT("showsPrec")
+showString_RDR = varQual_RDR pREL_SHOW FSLIT("showString")
+showSpace_RDR = varQual_RDR pREL_SHOW FSLIT("showSpace")
+showParen_RDR = varQual_RDR pREL_SHOW FSLIT("showParen")
+
+typeOf_RDR = varQual_RDR tYPEABLE FSLIT("typeOf")
+mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
+mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
+
+undefined_RDR = varQual_RDR pREL_ERR FSLIT("undefined")
+
+crossDataCon_RDR = dataQual_RDR pREL_BASE FSLIT(":*:")
+inlDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Inl")
+inrDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Inr")
+genUnitDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Unit")
+
+----------------------
+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)
+dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
+\end{code}
%************************************************************************
%* *
-\subsection{Commonly-used RdrNames}
+\subsection{Known-key names}
%* *
%************************************************************************
compiler (notably the deriving mechanism) need to mention their names,
and it's convenient to write them all down in one place.
-\begin{code}
-mainName = varQual mAIN_Name SLIT("main") mainKey
-
--- Stuff from PrelGHC
-usOnceTyConName = kindQual SLIT(".") usOnceTyConKey
-usManyTyConName = kindQual SLIT("!") usManyTyConKey
-superKindName = kindQual SLIT("KX") kindConKey
-superBoxityName = kindQual SLIT("BX") boxityConKey
-liftedConName = kindQual SLIT("*") liftedConKey
-unliftedConName = kindQual SLIT("#") unliftedConKey
-openKindConName = kindQual SLIT("?") anyBoxConKey
-usageKindConName = kindQual SLIT("$") usageConKey
-typeConName = kindQual SLIT("Type") typeConKey
-
-funTyConName = tcQual pREL_GHC_Name SLIT("(->)") funTyConKey
-charPrimTyConName = tcQual pREL_GHC_Name SLIT("Char#") charPrimTyConKey
-intPrimTyConName = tcQual pREL_GHC_Name SLIT("Int#") intPrimTyConKey
-int64PrimTyConName = tcQual pREL_GHC_Name SLIT("Int64#") int64PrimTyConKey
-wordPrimTyConName = tcQual pREL_GHC_Name SLIT("Word#") wordPrimTyConKey
-word64PrimTyConName = tcQual pREL_GHC_Name SLIT("Word64#") word64PrimTyConKey
-addrPrimTyConName = tcQual pREL_GHC_Name SLIT("Addr#") addrPrimTyConKey
-floatPrimTyConName = tcQual pREL_GHC_Name SLIT("Float#") floatPrimTyConKey
-doublePrimTyConName = tcQual pREL_GHC_Name SLIT("Double#") doublePrimTyConKey
-statePrimTyConName = tcQual pREL_GHC_Name SLIT("State#") statePrimTyConKey
-realWorldTyConName = tcQual pREL_GHC_Name SLIT("RealWorld") realWorldTyConKey
-arrayPrimTyConName = tcQual pREL_GHC_Name SLIT("Array#") arrayPrimTyConKey
-byteArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("ByteArray#") byteArrayPrimTyConKey
-mutableArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("MutableArray#") mutableArrayPrimTyConKey
-mutableByteArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("MutableByteArray#") mutableByteArrayPrimTyConKey
-mutVarPrimTyConName = tcQual pREL_GHC_Name SLIT("MutVar#") mutVarPrimTyConKey
-mVarPrimTyConName = tcQual pREL_GHC_Name SLIT("MVar#") mVarPrimTyConKey
-stablePtrPrimTyConName = tcQual pREL_GHC_Name SLIT("StablePtr#") stablePtrPrimTyConKey
-stableNamePrimTyConName = tcQual pREL_GHC_Name SLIT("StableName#") stableNamePrimTyConKey
-foreignObjPrimTyConName = tcQual pREL_GHC_Name SLIT("ForeignObj#") foreignObjPrimTyConKey
-bcoPrimTyConName = tcQual pREL_GHC_Name SLIT("BCO#") bcoPrimTyConKey
-weakPrimTyConName = tcQual pREL_GHC_Name SLIT("Weak#") weakPrimTyConKey
-threadIdPrimTyConName = tcQual pREL_GHC_Name SLIT("ThreadId#") threadIdPrimTyConKey
-cCallableClassName = clsQual pREL_GHC_Name SLIT("CCallable") cCallableClassKey
-cReturnableClassName = clsQual pREL_GHC_Name SLIT("CReturnable") cReturnableClassKey
-
--- PrelBase data types and constructors
-charTyConName = tcQual pREL_BASE_Name SLIT("Char") charTyConKey
-charDataConName = dataQual pREL_BASE_Name SLIT("C#") charDataConKey
-intTyConName = tcQual pREL_BASE_Name SLIT("Int") intTyConKey
-intDataConName = dataQual pREL_BASE_Name SLIT("I#") intDataConKey
-orderingTyConName = tcQual pREL_BASE_Name SLIT("Ordering") orderingTyConKey
-boolTyConName = tcQual pREL_BASE_Name SLIT("Bool") boolTyConKey
-falseDataConName = dataQual pREL_BASE_Name SLIT("False") falseDataConKey
-trueDataConName = dataQual pREL_BASE_Name SLIT("True") trueDataConKey
-listTyConName = tcQual pREL_BASE_Name SLIT("[]") listTyConKey
-nilDataConName = dataQual pREL_BASE_Name SLIT("[]") nilDataConKey
-consDataConName = dataQual pREL_BASE_Name SLIT(":") consDataConKey
+--MetaHaskell Extension add the constrs and the lower case case
+-- guys as well (perhaps) e.g. see trueDataConName below
--- Generics
-crossTyConName = tcQual pREL_BASE_Name SLIT(":*:") crossTyConKey
-crossDataConName = dataQual pREL_BASE_Name SLIT(":*:") crossDataConKey
-plusTyConName = tcQual pREL_BASE_Name SLIT(":+:") plusTyConKey
-inlDataConName = dataQual pREL_BASE_Name SLIT("Inl") inlDataConKey
-inrDataConName = dataQual pREL_BASE_Name SLIT("Inr") inrDataConKey
-genUnitTyConName = tcQual pREL_BASE_Name SLIT("Unit") genUnitTyConKey
-genUnitDataConName = dataQual pREL_BASE_Name SLIT("Unit") genUnitDataConKey
--- Random PrelBase functions
-unsafeCoerceName = varQual pREL_BASE_Name SLIT("unsafeCoerce") unsafeCoerceIdKey
-otherwiseIdName = varQual pREL_BASE_Name SLIT("otherwise") otherwiseIdKey
-appendName = varQual pREL_BASE_Name SLIT("++") appendIdKey
-foldrName = varQual pREL_BASE_Name SLIT("foldr") foldrIdKey
-mapName = varQual pREL_BASE_Name SLIT("map") mapIdKey
-buildName = varQual pREL_BASE_Name SLIT("build") buildIdKey
-augmentName = varQual pREL_BASE_Name SLIT("augment") augmentIdKey
-eqStringName = varQual pREL_BASE_Name SLIT("eqString") eqStringIdKey
-
--- Strings
-unpackCStringName = varQual pREL_BASE_Name SLIT("unpackCString#") unpackCStringIdKey
-unpackCStringAppendName = varQual pREL_BASE_Name SLIT("unpackAppendCString#") unpackCStringAppendIdKey
-unpackCStringFoldrName = varQual pREL_BASE_Name SLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
-unpackCStringUtf8Name = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
-
--- Classes Eq and Ord
-eqClassName = clsQual pREL_BASE_Name SLIT("Eq") eqClassKey
-ordClassName = clsQual pREL_BASE_Name SLIT("Ord") ordClassKey
-eqName = varQual pREL_BASE_Name SLIT("==") eqClassOpKey
-geName = varQual pREL_BASE_Name SLIT(">=") geClassOpKey
+\begin{code}
+runMainIOName = varQual pREL_TOP_HANDLER FSLIT("runMainIO") runMainKey
--- Class Monad
-monadClassName = clsQual pREL_BASE_Name SLIT("Monad") monadClassKey
-monadPlusClassName = clsQual pREL_BASE_Name SLIT("MonadPlus") monadPlusClassKey
-thenMName = varQual pREL_BASE_Name SLIT(">>=") thenMClassOpKey
-returnMName = varQual pREL_BASE_Name SLIT("return") returnMClassOpKey
-failMName = varQual pREL_BASE_Name SLIT("fail") failMClassOpKey
+orderingTyConName = tcQual pREL_BASE FSLIT("Ordering") orderingTyConKey
--- Class Functor
-functorClassName = clsQual pREL_BASE_Name SLIT("Functor") functorClassKey
+eitherTyConName = tcQual pREL_EITHER FSLIT("Either") eitherTyConKey
+leftDataConName = conName eitherTyConName FSLIT("Left") leftDataConKey
+rightDataConName = conName eitherTyConName FSLIT("Right") rightDataConKey
--- Class Show
-showClassName = clsQual pREL_SHOW_Name SLIT("Show") showClassKey
+-- Generics
+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 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 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 Read
-readClassName = clsQual pREL_READ_Name SLIT("Read") readClassKey
+-- Class Monad
+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 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 FSLIT("fst") fstIdKey
+sndName = varQual pREL_TUP FSLIT("snd") sndIdKey
-- Module PrelNum
-numClassName = clsQual pREL_NUM_Name SLIT("Num") numClassKey
-fromIntegerName = varQual pREL_NUM_Name SLIT("fromInteger") fromIntegerClassOpKey
-minusName = varQual pREL_NUM_Name SLIT("-") minusClassOpKey
-negateName = varQual pREL_NUM_Name SLIT("negate") negateClassOpKey
-plusIntegerName = varQual pREL_NUM_Name SLIT("plusInteger") plusIntegerIdKey
-timesIntegerName = varQual pREL_NUM_Name SLIT("timesInteger") timesIntegerIdKey
-integerTyConName = tcQual pREL_NUM_Name SLIT("Integer") integerTyConKey
-smallIntegerDataConName = dataQual pREL_NUM_Name SLIT("S#") smallIntegerDataConKey
-largeIntegerDataConName = dataQual pREL_NUM_Name SLIT("J#") largeIntegerDataConKey
+numClassName = clsQual pREL_NUM 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 SLIT("Rational") rationalTyConKey
-ratioTyConName = tcQual pREL_REAL_Name SLIT("Ratio") ratioTyConKey
-ratioDataConName = dataQual pREL_REAL_Name SLIT(":%") ratioDataConKey
-realClassName = clsQual pREL_REAL_Name SLIT("Real") realClassKey
-integralClassName = clsQual pREL_REAL_Name SLIT("Integral") integralClassKey
-realFracClassName = clsQual pREL_REAL_Name SLIT("RealFrac") realFracClassKey
-fractionalClassName = clsQual pREL_REAL_Name SLIT("Fractional") fractionalClassKey
-fromRationalName = varQual pREL_REAL_Name SLIT("fromRational") fromRationalClassOpKey
+rationalTyConName = tcQual pREL_REAL 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 = tcQual pREL_FLOAT_Name SLIT("Float") floatTyConKey
-floatDataConName = dataQual pREL_FLOAT_Name SLIT("F#") floatDataConKey
-doubleTyConName = tcQual pREL_FLOAT_Name SLIT("Double") doubleTyConKey
-doubleDataConName = dataQual pREL_FLOAT_Name SLIT("D#") doubleDataConKey
-floatingClassName = clsQual pREL_FLOAT_Name SLIT("Floating") floatingClassKey
-realFloatClassName = clsQual pREL_FLOAT_Name SLIT("RealFloat") realFloatClassKey
+floatingClassName = clsQual pREL_FLOAT FSLIT("Floating") floatingClassKey
+realFloatClassName = clsQual pREL_FLOAT FSLIT("RealFloat") realFloatClassKey
-- Class Ix
-ixClassName = clsQual pREL_ARR_Name SLIT("Ix") ixClassKey
+ixClassName = clsQual pREL_ARR FSLIT("Ix") ixClassKey
+
+-- Class Typeable
+typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey
+typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey
+typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey
+typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey
+typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey
+typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey
+typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey
+typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey
+
+typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
+ , typeable3ClassName, typeable4ClassName, typeable5ClassName
+ , typeable6ClassName, typeable7ClassName ]
+
+-- Class Data
+dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
+
+-- Error module
+assertErrorName = varQual pREL_ERR FSLIT("assertError") assertErrorIdKey
+
+-- Enum module (Enum, Bounded)
+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
--- Class Enum
-enumClassName = clsQual pREL_ENUM_Name SLIT("Enum") enumClassKey
-toEnumName = varQual pREL_ENUM_Name SLIT("toEnum") toEnumClassOpKey
-fromEnumName = varQual pREL_ENUM_Name SLIT("fromEnum") fromEnumClassOpKey
-enumFromName = varQual pREL_ENUM_Name SLIT("enumFrom") enumFromClassOpKey
-enumFromToName = varQual pREL_ENUM_Name SLIT("enumFromTo") enumFromToClassOpKey
-enumFromThenName = varQual pREL_ENUM_Name SLIT("enumFromThen") enumFromThenClassOpKey
-enumFromThenToName = varQual pREL_ENUM_Name SLIT("enumFromThenTo") enumFromThenToClassOpKey
+-- List functions
+concatName = varQual pREL_LIST FSLIT("concat") concatIdKey
+filterName = varQual pREL_LIST FSLIT("filter") filterIdKey
+zipName = varQual pREL_LIST FSLIT("zip") zipIdKey
--- Class Bounded
-boundedClassName = clsQual pREL_ENUM_Name SLIT("Bounded") boundedClassKey
+-- Class Show
+showClassName = clsQual pREL_SHOW FSLIT("Show") showClassKey
--- List functions
-concatName = varQual pREL_LIST_Name SLIT("concat") concatIdKey
-filterName = varQual pREL_LIST_Name SLIT("filter") filterIdKey
-zipName = varQual pREL_LIST_Name SLIT("zip") zipIdKey
+-- Class Read
+readClassName = clsQual pREL_READ FSLIT("Read") readClassKey
+
+-- parallel array types and functions
+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 SLIT("IO") ioTyConKey
-ioDataConName = dataQual pREL_IO_BASE_Name SLIT("IO") ioDataConKey
-bindIOName = varQual pREL_IO_BASE_Name SLIT("bindIO") bindIOIdKey
-returnIOName = varQual pREL_IO_BASE_Name SLIT("returnIO") returnIOIdKey
-failIOName = varQual pREL_IO_BASE_Name SLIT("failIO") failIOIdKey
+ioTyConName = tcQual pREL_IO_BASE 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 pREL_IO_Name SLIT("print") printIdKey
+printName = varQual sYSTEM_IO FSLIT("print") printIdKey
-- Int, Word, and Addr things
-int8TyConName = tcQual pREL_INT_Name SLIT("Int8") int8TyConKey
-int16TyConName = tcQual pREL_INT_Name SLIT("Int16") int16TyConKey
-int32TyConName = tcQual pREL_INT_Name SLIT("Int32") int32TyConKey
-int64TyConName = tcQual pREL_INT_Name SLIT("Int64") int64TyConKey
-
-word8TyConName = tcQual pREL_WORD_Name SLIT("Word8") word8TyConKey
-word16TyConName = tcQual pREL_WORD_Name SLIT("Word16") word16TyConKey
-word32TyConName = tcQual pREL_WORD_Name SLIT("Word32") word32TyConKey
-word64TyConName = tcQual pREL_WORD_Name SLIT("Word64") word64TyConKey
-
-wordTyConName = tcQual pREL_WORD_Name SLIT("Word") wordTyConKey
-wordDataConName = dataQual pREL_WORD_Name SLIT("W#") wordDataConKey
-
-addrTyConName = tcQual aDDR_Name SLIT("Addr") addrTyConKey
-addrDataConName = dataQual aDDR_Name SLIT("A#") addrDataConKey
-
-ptrTyConName = tcQual pREL_PTR_Name SLIT("Ptr") ptrTyConKey
-ptrDataConName = dataQual pREL_PTR_Name SLIT("Ptr") ptrDataConKey
+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 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 = tcQual aDDR FSLIT("Addr") addrTyConKey
+
+-- PrelPtr module
+ptrTyConName = tcQual pREL_PTR FSLIT("Ptr") ptrTyConKey
+funPtrTyConName = tcQual pREL_PTR FSLIT("FunPtr") funPtrTyConKey
-- Byte array types
-byteArrayTyConName = tcQual pREL_BYTEARR_Name SLIT("ByteArray") byteArrayTyConKey
-mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name SLIT("MutableByteArray") mutableByteArrayTyConKey
-
--- Forign objects and weak pointers
-foreignObjTyConName = tcQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjTyConKey
-foreignObjDataConName = dataQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjDataConKey
-foreignPtrTyConName = tcQual pREL_IO_BASE_Name SLIT("ForeignPtr") foreignPtrTyConKey
-foreignPtrDataConName = dataQual pREL_IO_BASE_Name SLIT("ForeignPtr") foreignPtrDataConKey
-stablePtrTyConName = tcQual pREL_STABLE_Name SLIT("StablePtr") stablePtrTyConKey
-stablePtrDataConName = dataQual pREL_STABLE_Name SLIT("StablePtr") stablePtrDataConKey
-deRefStablePtrName = varQual pREL_STABLE_Name SLIT("deRefStablePtr") deRefStablePtrIdKey
-newStablePtrName = varQual pREL_STABLE_Name SLIT("newStablePtr") newStablePtrIdKey
-
-errorName = varQual pREL_ERR_Name SLIT("error") errorIdKey
-assertName = varQual pREL_GHC_Name SLIT("assert") assertIdKey
-getTagName = varQual pREL_GHC_Name SLIT("getTag#") getTagIdKey
-runSTRepName = varQual pREL_ST_Name SLIT("runSTRep") runSTRepIdKey
-\end{code}
-
-%************************************************************************
-%* *
-\subsection{Known names}
-%* *
-%************************************************************************
-
-The following names are known to the compiler, but they don't require
-pre-assigned keys. Mostly these names are used in generating deriving
-code, which is passed through the renamer anyway.
-
- THEY ARE ALL ORIGINAL NAMES, HOWEVER
-
-\begin{code}
--- Lists and tuples
-tupleCon_RDR, tupleTyCon_RDR :: Int -> RdrName
-ubxTupleCon_RDR, ubxTupleTyCon_RDR :: Int -> RdrName
-
-tupleCon_RDR = mkTupConRdrName dataName Boxed
-tupleTyCon_RDR = mkTupConRdrName tcName Boxed
-ubxTupleCon_RDR = mkTupConRdrName dataName Unboxed
-ubxTupleTyCon_RDR = mkTupConRdrName tcName Unboxed
-
-unitCon_RDR = dataQual_RDR pREL_BASE_Name SLIT("()")
-unitTyCon_RDR = tcQual_RDR pREL_BASE_Name SLIT("()")
-
-and_RDR = varQual_RDR pREL_BASE_Name SLIT("&&")
-not_RDR = varQual_RDR pREL_BASE_Name SLIT("not")
-compose_RDR = varQual_RDR pREL_BASE_Name SLIT(".")
-ne_RDR = varQual_RDR pREL_BASE_Name SLIT("/=")
-le_RDR = varQual_RDR pREL_BASE_Name SLIT("<=")
-lt_RDR = varQual_RDR pREL_BASE_Name SLIT("<")
-gt_RDR = varQual_RDR pREL_BASE_Name SLIT(">")
-ltTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("LT")
-eqTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("EQ")
-gtTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("GT")
-max_RDR = varQual_RDR pREL_BASE_Name SLIT("max")
-min_RDR = varQual_RDR pREL_BASE_Name SLIT("min")
-compare_RDR = varQual_RDR pREL_BASE_Name SLIT("compare")
-showList_RDR = varQual_RDR pREL_SHOW_Name SLIT("showList")
-showList___RDR = varQual_RDR pREL_SHOW_Name SLIT("showList__")
-showsPrec_RDR = varQual_RDR pREL_SHOW_Name SLIT("showsPrec")
-showSpace_RDR = varQual_RDR pREL_SHOW_Name SLIT("showSpace")
-showString_RDR = varQual_RDR pREL_SHOW_Name SLIT("showString")
-showParen_RDR = varQual_RDR pREL_SHOW_Name SLIT("showParen")
-readsPrec_RDR = varQual_RDR pREL_READ_Name SLIT("readsPrec")
-readList_RDR = varQual_RDR pREL_READ_Name SLIT("readList")
-readParen_RDR = varQual_RDR pREL_READ_Name SLIT("readParen")
-lex_RDR = varQual_RDR pREL_READ_Name SLIT("lex")
-readList___RDR = varQual_RDR pREL_READ_Name SLIT("readList__")
-times_RDR = varQual_RDR pREL_NUM_Name SLIT("*")
-plus_RDR = varQual_RDR pREL_NUM_Name SLIT("+")
-negate_RDR = varQual_RDR pREL_NUM_Name SLIT("negate")
-range_RDR = varQual_RDR pREL_ARR_Name SLIT("range")
-index_RDR = varQual_RDR pREL_ARR_Name SLIT("index")
-inRange_RDR = varQual_RDR pREL_ARR_Name SLIT("inRange")
-succ_RDR = varQual_RDR pREL_ENUM_Name SLIT("succ")
-pred_RDR = varQual_RDR pREL_ENUM_Name SLIT("pred")
-minBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("minBound")
-maxBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("maxBound")
-assertErr_RDR = varQual_RDR pREL_ERR_Name SLIT("assertError")
-\end{code}
-
-These RDR names also have known keys, so we need to get back the RDR names to
-populate the occurrence list above.
-
-\begin{code}
-funTyCon_RDR = nameRdrName funTyConName
-nilCon_RDR = nameRdrName nilDataConName
-listTyCon_RDR = nameRdrName listTyConName
-ioTyCon_RDR = nameRdrName ioTyConName
-intTyCon_RDR = nameRdrName intTyConName
-eq_RDR = nameRdrName eqName
-ge_RDR = nameRdrName geName
-numClass_RDR = nameRdrName numClassName
-ordClass_RDR = nameRdrName ordClassName
-map_RDR = nameRdrName mapName
-append_RDR = nameRdrName appendName
-foldr_RDR = nameRdrName foldrName
-build_RDR = nameRdrName buildName
-enumFromTo_RDR = nameRdrName enumFromToName
-returnM_RDR = nameRdrName returnMName
-thenM_RDR = nameRdrName thenMName
-failM_RDR = nameRdrName failMName
-false_RDR = nameRdrName falseDataConName
-true_RDR = nameRdrName trueDataConName
-error_RDR = nameRdrName errorName
-getTag_RDR = nameRdrName getTagName
-fromEnum_RDR = nameRdrName fromEnumName
-toEnum_RDR = nameRdrName toEnumName
-enumFrom_RDR = nameRdrName enumFromName
-mkInt_RDR = nameRdrName intDataConName
-enumFromThen_RDR = nameRdrName enumFromThenName
-enumFromThenTo_RDR = nameRdrName enumFromThenToName
-ratioDataCon_RDR = nameRdrName ratioDataConName
-plusInteger_RDR = nameRdrName plusIntegerName
-timesInteger_RDR = nameRdrName timesIntegerName
-enumClass_RDR = nameRdrName enumClassName
-monadClass_RDR = nameRdrName monadClassName
-ioDataCon_RDR = nameRdrName ioDataConName
-cCallableClass_RDR = nameRdrName cCallableClassName
-cReturnableClass_RDR = nameRdrName cReturnableClassName
-eqClass_RDR = nameRdrName eqClassName
-eqString_RDR = nameRdrName eqStringName
-unpackCString_RDR = nameRdrName unpackCStringName
-unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
-unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
-deRefStablePtr_RDR = nameRdrName deRefStablePtrName
-newStablePtr_RDR = nameRdrName newStablePtrName
-bindIO_RDR = nameRdrName bindIOName
-returnIO_RDR = nameRdrName returnIOName
-fromInteger_RDR = nameRdrName fromIntegerName
-fromRational_RDR = nameRdrName fromRationalName
-minus_RDR = nameRdrName minusName
+byteArrayTyConName = tcQual pREL_BYTEARR FSLIT("ByteArray") byteArrayTyConKey
+mutableByteArrayTyConName = tcQual pREL_BYTEARR FSLIT("MutableByteArray") mutableByteArrayTyConKey
+
+-- Foreign objects and weak pointers
+stablePtrTyConName = tcQual pREL_STABLE FSLIT("StablePtr") stablePtrTyConKey
+newStablePtrName = varQual pREL_STABLE FSLIT("newStablePtr") newStablePtrIdKey
+
+-- PrelST module
+runSTRepName = varQual pREL_ST FSLIT("runSTRep") runSTRepIdKey
+
+-- The "split" Id for splittable implicit parameters
+splittableClassName = clsQual gLA_EXTS FSLIT("Splittable") splittableClassKey
+splitName = methName splittableClassName FSLIT("split") splitIdKey
+
+-- Recursive-do notation
+monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
+mfixName = methName monadFixClassName 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
+
+-- Other classes, needed for type defaulting
+monadPlusClassName = clsQual mONAD FSLIT("MonadPlus") monadPlusClassKey
+randomClassName = clsQual rANDOM FSLIT("Random") randomClassKey
+randomGenClassName = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey
+
+-- 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}
%************************************************************************
All these are original names; hence mkOrig
\begin{code}
-varQual mod str uq = mkKnownKeyGlobal (varQual_RDR mod str) uq
-dataQual mod str uq = mkKnownKeyGlobal (dataQual_RDR mod str) uq
-tcQual mod str uq = mkKnownKeyGlobal (tcQual_RDR mod str) uq
-clsQual mod str uq = mkKnownKeyGlobal (clsQual_RDR mod str) uq
-
-kindQual str uq = mkLocalName uq (mkKindOccFS tcName str) builtinSrcLoc
- -- Kinds are not z-encoded in interface file, hence mkKindOccFS
- -- And they don't come from any particular module; indeed we always
- -- want to print them unqualified. Hence the LocalName
-
-varQual_RDR mod str = mkOrig varName mod str
-tcQual_RDR mod str = mkOrig tcName mod str
-clsQual_RDR mod str = mkOrig clsName mod str
-dataQual_RDR mod str = mkOrig dataName mod str
+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)
+ Nothing noSrcLoc
+
+conName :: Name -> FastString -> Unique -> Name
+conName tycon occ uniq
+ = mkExternalName uniq (nameModule tycon) (mkOccNameFS dataName occ)
+ (Just tycon) noSrcLoc
+
+methName :: Name -> FastString -> Unique -> Name
+methName cls occ uniq
+ = mkExternalName uniq (nameModule cls) (mkVarOccFS occ)
+ (Just cls) noSrcLoc
\end{code}
%************************************************************************
\subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
%* *
%************************************************************************
+--MetaHaskell extension hand allocate keys here
\begin{code}
boundedClassKey = mkPreludeClassUnique 1
fractionalClassKey = mkPreludeClassUnique 6
integralClassKey = mkPreludeClassUnique 7
monadClassKey = mkPreludeClassUnique 8
-monadPlusClassKey = mkPreludeClassUnique 9
+dataClassKey = mkPreludeClassUnique 9
functorClassKey = mkPreludeClassUnique 10
numClassKey = mkPreludeClassUnique 11
ordClassKey = mkPreludeClassUnique 12
realFloatClassKey = mkPreludeClassUnique 15
realFracClassKey = mkPreludeClassUnique 16
showClassKey = mkPreludeClassUnique 17
-
-cCallableClassKey = mkPreludeClassUnique 18
-cReturnableClassKey = mkPreludeClassUnique 19
-
-ixClassKey = mkPreludeClassUnique 20
+ixClassKey = mkPreludeClassUnique 18
+
+typeableClassKey = mkPreludeClassUnique 20
+typeable1ClassKey = mkPreludeClassUnique 21
+typeable2ClassKey = mkPreludeClassUnique 22
+typeable3ClassKey = mkPreludeClassUnique 23
+typeable4ClassKey = mkPreludeClassUnique 24
+typeable5ClassKey = mkPreludeClassUnique 25
+typeable6ClassKey = mkPreludeClassUnique 26
+typeable7ClassKey = mkPreludeClassUnique 27
+
+monadFixClassKey = mkPreludeClassUnique 28
+splittableClassKey = mkPreludeClassUnique 29
+
+monadPlusClassKey = mkPreludeClassUnique 30
+randomClassKey = mkPreludeClassUnique 31
+randomGenClassKey = mkPreludeClassUnique 32
\end{code}
%************************************************************************
intTyConKey = mkPreludeTyConUnique 15
int8TyConKey = mkPreludeTyConUnique 16
int16TyConKey = mkPreludeTyConUnique 17
-int32TyConKey = mkPreludeTyConUnique 18
-int64PrimTyConKey = mkPreludeTyConUnique 19
-int64TyConKey = mkPreludeTyConUnique 20
-integerTyConKey = mkPreludeTyConUnique 21
-listTyConKey = mkPreludeTyConUnique 22
-foreignObjPrimTyConKey = mkPreludeTyConUnique 23
-foreignObjTyConKey = mkPreludeTyConUnique 24
-foreignPtrTyConKey = mkPreludeTyConUnique 25
-weakPrimTyConKey = mkPreludeTyConUnique 26
-mutableArrayPrimTyConKey = mkPreludeTyConUnique 27
-mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 28
-orderingTyConKey = mkPreludeTyConUnique 29
-mVarPrimTyConKey = mkPreludeTyConUnique 30
-ratioTyConKey = mkPreludeTyConUnique 31
-rationalTyConKey = mkPreludeTyConUnique 32
-realWorldTyConKey = mkPreludeTyConUnique 33
-stablePtrPrimTyConKey = mkPreludeTyConUnique 34
-stablePtrTyConKey = mkPreludeTyConUnique 35
-statePrimTyConKey = mkPreludeTyConUnique 36
-stableNamePrimTyConKey = mkPreludeTyConUnique 50
-stableNameTyConKey = mkPreludeTyConUnique 51
-mutableByteArrayTyConKey = mkPreludeTyConUnique 52
-mutVarPrimTyConKey = mkPreludeTyConUnique 53
-ioTyConKey = mkPreludeTyConUnique 55
-byteArrayTyConKey = mkPreludeTyConUnique 56
-wordPrimTyConKey = mkPreludeTyConUnique 57
-wordTyConKey = mkPreludeTyConUnique 58
-word8TyConKey = mkPreludeTyConUnique 59
-word16TyConKey = mkPreludeTyConUnique 60
-word32TyConKey = mkPreludeTyConUnique 61
-word64PrimTyConKey = mkPreludeTyConUnique 62
-word64TyConKey = mkPreludeTyConUnique 63
-liftedConKey = mkPreludeTyConUnique 64
-unliftedConKey = mkPreludeTyConUnique 65
-anyBoxConKey = mkPreludeTyConUnique 66
-kindConKey = mkPreludeTyConUnique 67
-boxityConKey = mkPreludeTyConUnique 68
-typeConKey = mkPreludeTyConUnique 69
-threadIdPrimTyConKey = mkPreludeTyConUnique 70
-bcoPrimTyConKey = mkPreludeTyConUnique 71
-ptrTyConKey = mkPreludeTyConUnique 72
-
--- Usage type constructors
-usageConKey = mkPreludeTyConUnique 73
-usOnceTyConKey = mkPreludeTyConUnique 74
-usManyTyConKey = mkPreludeTyConUnique 75
+int32PrimTyConKey = mkPreludeTyConUnique 18
+int32TyConKey = mkPreludeTyConUnique 19
+int64PrimTyConKey = mkPreludeTyConUnique 20
+int64TyConKey = mkPreludeTyConUnique 21
+integerTyConKey = mkPreludeTyConUnique 22
+listTyConKey = mkPreludeTyConUnique 23
+foreignObjPrimTyConKey = mkPreludeTyConUnique 24
+weakPrimTyConKey = mkPreludeTyConUnique 27
+mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
+mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
+orderingTyConKey = mkPreludeTyConUnique 30
+mVarPrimTyConKey = mkPreludeTyConUnique 31
+ratioTyConKey = mkPreludeTyConUnique 32
+rationalTyConKey = mkPreludeTyConUnique 33
+realWorldTyConKey = mkPreludeTyConUnique 34
+stablePtrPrimTyConKey = mkPreludeTyConUnique 35
+stablePtrTyConKey = mkPreludeTyConUnique 36
+statePrimTyConKey = mkPreludeTyConUnique 50
+stableNamePrimTyConKey = mkPreludeTyConUnique 51
+stableNameTyConKey = mkPreludeTyConUnique 52
+mutableByteArrayTyConKey = mkPreludeTyConUnique 53
+mutVarPrimTyConKey = mkPreludeTyConUnique 55
+ioTyConKey = mkPreludeTyConUnique 56
+byteArrayTyConKey = mkPreludeTyConUnique 57
+wordPrimTyConKey = mkPreludeTyConUnique 58
+wordTyConKey = mkPreludeTyConUnique 59
+word8TyConKey = mkPreludeTyConUnique 60
+word16TyConKey = mkPreludeTyConUnique 61
+word32PrimTyConKey = mkPreludeTyConUnique 62
+word32TyConKey = mkPreludeTyConUnique 63
+word64PrimTyConKey = mkPreludeTyConUnique 64
+word64TyConKey = mkPreludeTyConUnique 65
+liftedConKey = mkPreludeTyConUnique 66
+unliftedConKey = mkPreludeTyConUnique 67
+anyBoxConKey = mkPreludeTyConUnique 68
+kindConKey = mkPreludeTyConUnique 69
+boxityConKey = mkPreludeTyConUnique 70
+typeConKey = mkPreludeTyConUnique 71
+threadIdPrimTyConKey = mkPreludeTyConUnique 72
+bcoPrimTyConKey = mkPreludeTyConUnique 73
+ptrTyConKey = mkPreludeTyConUnique 74
+funPtrTyConKey = mkPreludeTyConUnique 75
+tVarPrimTyConKey = mkPreludeTyConUnique 76
-- Generic Type Constructors
-crossTyConKey = mkPreludeTyConUnique 76
-plusTyConKey = mkPreludeTyConUnique 77
-genUnitTyConKey = mkPreludeTyConUnique 78
+crossTyConKey = mkPreludeTyConUnique 79
+plusTyConKey = mkPreludeTyConUnique 80
+genUnitTyConKey = mkPreludeTyConUnique 81
+
+-- Parallel array type constructor
+parrTyConKey = mkPreludeTyConUnique 82
+
+-- dotnet interop
+objectTyConKey = mkPreludeTyConUnique 83
+
+eitherTyConKey = mkPreludeTyConUnique 84
+
+---------------- Template Haskell -------------------
+-- USES TyConUniques 100-129
+-----------------------------------------------------
+
+unitTyConKey = mkTupleTyConUnique Boxed 0
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-addrDataConKey = mkPreludeDataConUnique 0
charDataConKey = mkPreludeDataConUnique 1
consDataConKey = mkPreludeDataConUnique 2
doubleDataConKey = mkPreludeDataConUnique 3
intDataConKey = mkPreludeDataConUnique 6
smallIntegerDataConKey = mkPreludeDataConUnique 7
largeIntegerDataConKey = mkPreludeDataConUnique 8
-foreignObjDataConKey = mkPreludeDataConUnique 9
-foreignPtrDataConKey = mkPreludeDataConUnique 10
nilDataConKey = mkPreludeDataConUnique 11
ratioDataConKey = mkPreludeDataConUnique 12
-stablePtrDataConKey = mkPreludeDataConUnique 13
stableNameDataConKey = mkPreludeDataConUnique 14
trueDataConKey = mkPreludeDataConUnique 15
wordDataConKey = mkPreludeDataConUnique 16
ioDataConKey = mkPreludeDataConUnique 17
-ptrDataConKey = mkPreludeDataConUnique 18
-- Generic data constructors
-crossDataConKey = mkPreludeDataConUnique 19
-inlDataConKey = mkPreludeDataConUnique 20
-inrDataConKey = mkPreludeDataConUnique 21
-genUnitDataConKey = mkPreludeDataConUnique 22
+crossDataConKey = mkPreludeDataConUnique 20
+inlDataConKey = mkPreludeDataConUnique 21
+inrDataConKey = mkPreludeDataConUnique 22
+genUnitDataConKey = mkPreludeDataConUnique 23
+
+-- Data constructor for parallel arrays
+parrDataConKey = mkPreludeDataConUnique 24
+
+leftDataConKey = mkPreludeDataConUnique 25
+rightDataConKey = mkPreludeDataConUnique 26
\end{code}
%************************************************************************
\begin{code}
absentErrorIdKey = mkPreludeMiscIdUnique 1
-appendIdKey = mkPreludeMiscIdUnique 2
augmentIdKey = mkPreludeMiscIdUnique 3
-buildIdKey = mkPreludeMiscIdUnique 4
-errorIdKey = mkPreludeMiscIdUnique 5
-foldlIdKey = mkPreludeMiscIdUnique 6
-foldrIdKey = mkPreludeMiscIdUnique 7
-recSelErrIdKey = mkPreludeMiscIdUnique 8
-integerMinusOneIdKey = mkPreludeMiscIdUnique 9
-integerPlusOneIdKey = mkPreludeMiscIdUnique 10
-integerPlusTwoIdKey = mkPreludeMiscIdUnique 11
-integerZeroIdKey = mkPreludeMiscIdUnique 12
-int2IntegerIdKey = mkPreludeMiscIdUnique 13
-irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15
-eqStringIdKey = mkPreludeMiscIdUnique 16
-noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17
-nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
-parErrorIdKey = mkPreludeMiscIdUnique 20
-parIdKey = mkPreludeMiscIdUnique 21
-patErrorIdKey = mkPreludeMiscIdUnique 22
-realWorldPrimIdKey = mkPreludeMiscIdUnique 23
-recConErrorIdKey = mkPreludeMiscIdUnique 24
-recUpdErrorIdKey = mkPreludeMiscIdUnique 25
-traceIdKey = mkPreludeMiscIdUnique 26
-unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 27
-unpackCStringAppendIdKey = mkPreludeMiscIdUnique 28
-unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 29
-unpackCStringIdKey = mkPreludeMiscIdUnique 30
-ushowListIdKey = mkPreludeMiscIdUnique 31
+appendIdKey = mkPreludeMiscIdUnique 4
+buildIdKey = mkPreludeMiscIdUnique 5
+errorIdKey = mkPreludeMiscIdUnique 6
+foldlIdKey = mkPreludeMiscIdUnique 7
+foldrIdKey = mkPreludeMiscIdUnique 8
+recSelErrorIdKey = mkPreludeMiscIdUnique 9
+integerMinusOneIdKey = mkPreludeMiscIdUnique 10
+integerPlusOneIdKey = mkPreludeMiscIdUnique 11
+integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
+integerZeroIdKey = mkPreludeMiscIdUnique 13
+int2IntegerIdKey = mkPreludeMiscIdUnique 14
+seqIdKey = mkPreludeMiscIdUnique 15
+irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
+eqStringIdKey = mkPreludeMiscIdUnique 17
+noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
+nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
+runtimeErrorIdKey = mkPreludeMiscIdUnique 20
+parErrorIdKey = mkPreludeMiscIdUnique 21
+parIdKey = mkPreludeMiscIdUnique 22
+patErrorIdKey = mkPreludeMiscIdUnique 23
+realWorldPrimIdKey = mkPreludeMiscIdUnique 24
+recConErrorIdKey = mkPreludeMiscIdUnique 25
+recUpdErrorIdKey = mkPreludeMiscIdUnique 26
+traceIdKey = mkPreludeMiscIdUnique 27
+unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
+unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
+unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
+unpackCStringIdKey = mkPreludeMiscIdUnique 31
+
unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
concatIdKey = mkPreludeMiscIdUnique 33
filterIdKey = mkPreludeMiscIdUnique 34
returnIOIdKey = mkPreludeMiscIdUnique 37
deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
newStablePtrIdKey = mkPreludeMiscIdUnique 39
-getTagIdKey = mkPreludeMiscIdUnique 40
plusIntegerIdKey = mkPreludeMiscIdUnique 41
timesIntegerIdKey = mkPreludeMiscIdUnique 42
printIdKey = mkPreludeMiscIdUnique 43
failIOIdKey = mkPreludeMiscIdUnique 44
+nullAddrIdKey = mkPreludeMiscIdUnique 46
+voidArgIdKey = mkPreludeMiscIdUnique 47
+splitIdKey = mkPreludeMiscIdUnique 48
+fstIdKey = mkPreludeMiscIdUnique 49
+sndIdKey = mkPreludeMiscIdUnique 50
+otherwiseIdKey = mkPreludeMiscIdUnique 51
+assertIdKey = mkPreludeMiscIdUnique 53
+runSTRepIdKey = mkPreludeMiscIdUnique 54
+
+rootMainKey = mkPreludeMiscIdUnique 55
+runMainKey = mkPreludeMiscIdUnique 56
+
+andIdKey = mkPreludeMiscIdUnique 57
+orIdKey = mkPreludeMiscIdUnique 58
+thenIOIdKey = mkPreludeMiscIdUnique 59
+lazyIdKey = mkPreludeMiscIdUnique 60
+assertErrorIdKey = mkPreludeMiscIdUnique 61
+
+-- Parallel array functions
+nullPIdKey = mkPreludeMiscIdUnique 80
+lengthPIdKey = mkPreludeMiscIdUnique 81
+replicatePIdKey = mkPreludeMiscIdUnique 82
+mapPIdKey = mkPreludeMiscIdUnique 83
+filterPIdKey = mkPreludeMiscIdUnique 84
+zipPIdKey = mkPreludeMiscIdUnique 85
+crossPIdKey = mkPreludeMiscIdUnique 86
+indexPIdKey = mkPreludeMiscIdUnique 87
+toPIdKey = mkPreludeMiscIdUnique 88
+enumFromToPIdKey = mkPreludeMiscIdUnique 89
+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
during type checking.
\begin{code}
+ -- Just a place holder for unbound variables produced by the renamer:
+unboundKey = mkPreludeMiscIdUnique 101
+
fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
minusClassOpKey = mkPreludeMiscIdUnique 103
fromRationalClassOpKey = mkPreludeMiscIdUnique 104
geClassOpKey = mkPreludeMiscIdUnique 110
negateClassOpKey = mkPreludeMiscIdUnique 111
failMClassOpKey = mkPreludeMiscIdUnique 112
-thenMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
- -- Just a place holder for unbound variables produced by the renamer:
-unboundKey = mkPreludeMiscIdUnique 114
-fromEnumClassOpKey = mkPreludeMiscIdUnique 115
-
-mainKey = mkPreludeMiscIdUnique 116
+bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
+thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
returnMClassOpKey = mkPreludeMiscIdUnique 117
-otherwiseIdKey = mkPreludeMiscIdUnique 118
-toEnumClassOpKey = mkPreludeMiscIdUnique 119
-mapIdKey = mkPreludeMiscIdUnique 120
-\end{code}
-\begin{code}
-assertIdKey = mkPreludeMiscIdUnique 121
-runSTRepIdKey = mkPreludeMiscIdUnique 122
-itIdKey = mkPreludeMiscIdUnique 123 -- "it" for the interactive interface
+-- 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-399
+-----------------------------------------------------
\end{code}
, wordTyConKey
, byteArrayTyConKey
, mutableByteArrayTyConKey
- , foreignObjTyConKey
- , foreignPtrTyConKey
, stablePtrTyConKey
, int8TyConKey
, int16TyConKey
%************************************************************************
%* *
-\subsection{Re-bindable desugaring names}
-%* *
-%************************************************************************
-
-Haskell 98 says that when you say "3" you get the "fromInteger" from the
-Standard Prelude, regardless of what is in scope. However, to experiment
-with having a language that is less coupled to the standard prelude, we're
-trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
-happens to be in scope. Then you can
- import Prelude ()
- import MyPrelude as Prelude
-to get the desired effect.
-
-The SyntaxNames record gives all the names you can rebind in this way.
-This record of names needs to go through the renamer to map RdrNames to
-Names (i.e. look up the names in the in-scope environment), to suck in
-their type signatures from interface file(s).
-
-\begin{code}
-type SyntaxList = [(Name, RdrName)]
- -- Maps a Name, which identifies the standard built-in thing
- -- to a RdrName for the re-mapped version of the built-in thing
-
-syntaxList :: SyntaxList
-syntaxList =[ (fromIntegerName, mkUnqual varName SLIT("fromInteger"))
- , (fromRationalName, mkUnqual varName SLIT("fromRational"))
- , (negateName, mkUnqual varName SLIT("negate"))
- , (minusName, mkUnqual varName SLIT("-"))
- -- For now that's all. We may add booleans and lists later.
- ]
-
-
-type SyntaxMap = Name -> Name
- -- Maps a standard built-in name, such as PrelNum.fromInteger
- -- to its re-mapped version, such as MyPrelude.fromInteger
-
-vanillaSyntaxMap name = name
-\end{code}
-
-
-%************************************************************************
-%* *
\subsection[Class-std-groups]{Standard groups of Prelude classes}
%* *
%************************************************************************
-@derivableClassKeys@ is also used in checking \tr{deriving} constructs
-(@TcDeriv@).
-
-@derivingOccurrences@ maps a class name to a list of the (qualified)
-occurrences that will be mentioned by the derived code for the class
-when it is later generated. We don't need to put in things that are
-WiredIn (because they are already mapped to their correct name by the
-@NameSupply@. The class itself, and all its class ops, is already
-flagged as an occurrence so we don't need to mention that either.
-
-@derivingOccurrences@ has an item for every derivable class, even if
-that item is empty, because we treat lookup failure as indicating that
-the class is illegal in a deriving clause.
-
-\begin{code}
-derivingOccurrences :: UniqFM [RdrName]
-derivingOccurrences = listToUFM deriving_occ_info
-
-derivableClassKeys = map fst deriving_occ_info
-
-deriving_occ_info
- = [ (eqClassKey, [intTyCon_RDR, and_RDR, not_RDR])
- , (ordClassKey, [intTyCon_RDR, compose_RDR, eqTag_RDR])
- -- EQ (from Ordering) is needed to force in the constructors
- -- as well as the type constructor.
- , (enumClassKey, [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
- -- The last two Enum deps are only used to produce better
- -- error msgs for derived toEnum methods.
- , (boundedClassKey, [intTyCon_RDR])
- , (showClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
- showParen_RDR, showSpace_RDR, showList___RDR])
- , (readClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
- foldr_RDR, build_RDR,
- -- foldr and build required for list comprehension
- -- KSW 2000-06
- lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
- -- returnM (and the rest of the Monad class decl)
- -- will be forced in as result of depending
- -- on thenM. -- SOF 1/99
- , (ixClassKey, [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
- foldr_RDR, build_RDR,
- -- foldr and build required for list comprehension used
- -- with single constructor types -- KSW 2000-06
- returnM_RDR, failM_RDR])
- -- the last two are needed to force returnM, thenM and failM
- -- in before typechecking the list(monad) comprehension
- -- generated for derived Ix instances (range method)
- -- of single constructor types. -- SOF 8/97
- ]
- -- intTyCon: Practically any deriving needs Int, either for index calculations,
- -- or for taggery.
- -- ordClass: really it's the methods that are actually used.
- -- numClass: for Int literals
-\end{code}
-
-
NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
even though every numeric class has these two as a superclass,
because the list of ambiguous dictionaries hasn't been simplified.
[ readClassKey
]
-cCallishClassKeys =
- [ cCallableClassKey
- , cReturnableClassKey
- ]
+-- 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 = derivableClassKeys ++ numericClassKeys
+ ++ [randomClassKey, randomGenClassKey,
+ functorClassKey,
+ monadClassKey, monadPlusClassKey]
+\end{code}
-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
+@derivableClassKeys@ is also used in checking \tr{deriving} constructs
+(@TcDeriv@).
+
+\begin{code}
+derivableClassKeys
+ = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
+ boundedClassKey, showClassKey, readClassKey ]
\end{code}
projects / ghc-hetmet.git / blobdiff