Nota Bene: all Names defined in here should come from the base package
-* ModuleNames for prelude modules,
+ - ModuleNames for prelude modules,
e.g. pREL_BASE_Name :: ModuleName
-* Modules for prelude modules
+ - Modules for prelude modules
e.g. pREL_Base :: Module
-* Uniques for Ids, DataCons, TyCons and Classes that the compiler
- "knows about" in some way
+ - 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
+ - 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
+ 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.
+ 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
+ - 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}
#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,
mkTupleTyConUnique
)
import BasicTypes ( Boxity(..), Arity )
-import Name ( Name, mkInternalName, mkExternalName )
+import Name ( Name, mkInternalName, mkExternalName, mkSystemVarName )
import SrcLoc
import FastString
\end{code}
This *local* name is used by the interactive stuff
\begin{code}
-itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcSpan
+itName :: Unique -> Name
+itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan
\end{code}
\begin{code}
%************************************************************************
-%* *
+%* *
\subsection{Known key Names}
-%* *
+%* *
%************************************************************************
-This section tells what the compiler knows about the assocation of
+This section tells what the compiler knows about the association of
names with uniques. These ones are the *non* wired-in ones. The
wired in ones are defined in TysWiredIn etc.
+The names for DPH can come from one of multiple backend packages. At the point where
+'basicKnownKeyNames' is used, we don't know which backend it will be. Hence, we list
+the names for multiple backends. That works out fine, although they use the same uniques,
+as we are guaranteed to only load one backend; hence, only one of the different names
+sharing a unique will be used.
+
\begin{code}
basicKnownKeyNames :: [Name]
basicKnownKeyNames
= genericTyConNames
++ typeableClassNames
- ++ ndpNames
+ ++ dphKnownKeyNames dphSeqPackageId ++ dphKnownKeyNames dphParPackageId
++ [ -- Type constructors (synonyms especially)
ioTyConName, ioDataConName,
runMainIOName,
stringTyConName,
ratioDataConName,
ratioTyConName,
- integerTyConName, smallIntegerDataConName, largeIntegerDataConName,
+ integerTyConName, smallIntegerName,
-- Classes. *Must* include:
-- classes that are grabbed by key (e.g., eqClassKey)
realFloatClassName, -- numeric
dataClassName,
isStringClassName,
+ applicativeClassName,
+ foldableClassName,
+ traversableClassName,
-- Numeric stuff
- negateName, minusName,
- fromRationalName, fromIntegerName,
- geName, eqName,
+ negateName, minusName, geName, eqName,
+
+ -- Conversion functions
+ fromRationalName, fromIntegerName,
+ toIntegerName, toRationalName,
+ fromIntegralName, realToFracName,
-- String stuff
fromStringName,
-- Enum stuff
enumFromName, enumFromThenName,
enumFromThenToName, enumFromToName,
- enumFromToPName, enumFromThenToPName,
-- Monad stuff
thenIOName, bindIOName, returnIOName, failIOName,
failMName, bindMName, thenMName, returnMName,
+ fmapName,
-- MonadRec stuff
mfixName,
-- Read stuff
readClassName,
-
+
-- 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, crossMapPName, indexPName,
- toPName, bpermutePName, bpermuteDftPName, indexOfPName,
+ dollarName, -- The ($) apply function
-- FFI primitive types that are not wired-in.
stablePtrTyConName, ptrTyConName, funPtrTyConName,
-- Other classes
randomClassName, randomGenClassName, monadPlusClassName,
- -- Booleans
- andName, orName
-
+ -- Code types
+ hetmet_brak_name, hetmet_esc_name, hetmet_csp_name, hetmet_flatten_name, hetmet_unflatten_name, hetmet_flattened_id_name,
+ hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name,
+ hetmet_guest_char_literal_name,
+ hetmet_PGArrow_name,
+ hetmet_PGArrow_unit_name,
+ hetmet_PGArrow_tensor_name,
+ hetmet_PGArrow_exponent_name,
+ hetmet_pga_id_name,
+ hetmet_pga_comp_name,
+ hetmet_pga_first_name,
+ hetmet_pga_second_name,
+ hetmet_pga_cancell_name,
+ hetmet_pga_cancelr_name,
+ hetmet_pga_uncancell_name,
+ hetmet_pga_uncancelr_name,
+ hetmet_pga_assoc_name,
+ hetmet_pga_unassoc_name,
+ hetmet_pga_copy_name,
+ hetmet_pga_drop_name,
+ hetmet_pga_swap_name,
+ hetmet_pga_applyl_name,
+ hetmet_pga_applyr_name,
+ hetmet_pga_curryl_name,
+ hetmet_pga_curryr_name,
+
+ -- Annotation type checking
+ toAnnotationWrapperName
+
-- The Either type
, eitherTyConName, leftDataConName, rightDataConName
-- dotnet interop
, objectTyConName, marshalObjectName, unmarshalObjectName
, marshalStringName, unmarshalStringName, checkDotnetResName
+
+ -- Generics
+ , genClassName, gen1ClassName
+ , datatypeClassName, constructorClassName, selectorClassName
+
+ -- Monad comprehensions
+ , guardMName
+ , liftMName
+ , groupMName
+ , mzipName
]
genericTyConNames :: [Name]
-genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
+genericTyConNames = [
+ v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
+ k1TyConName, m1TyConName, sumTyConName, prodTyConName,
+ compTyConName, rTyConName, pTyConName, dTyConName,
+ cTyConName, sTyConName, rec0TyConName, par0TyConName,
+ d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
+ repTyConName, rep1TyConName
+ ]
+
+-- Know names from the DPH package which vary depending on the selected DPH backend.
+--
+dphKnownKeyNames :: PackageId -> [Name]
+dphKnownKeyNames dphPkg
+ = map ($ dphPkg)
+ [
+ -- Parallel array operations
+ nullPName, lengthPName, replicatePName, singletonPName, mapPName,
+ filterPName, zipPName, crossMapPName, indexPName,
+ toPName, emptyPName, appPName,
+ enumFromToPName, enumFromThenToPName
-ndpNames :: [Name]
-ndpNames = [ parrayTyConName, paTyConName, closureTyConName
- , mkClosureName, applyClosureName
- , mkClosurePName, applyClosurePName
- , lengthPAName, replicatePAName, emptyPAName ]
+ ]
\end{code}
--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_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_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")
-gHC_ST = mkBaseModule FSLIT("GHC.ST")
-gHC_ARR = mkBaseModule FSLIT("GHC.Arr")
-gHC_STABLE = mkBaseModule FSLIT("GHC.Stable")
-gHC_ADDR = mkBaseModule FSLIT("GHC.Addr")
-gHC_PTR = mkBaseModule FSLIT("GHC.Ptr")
-gHC_ERR = mkBaseModule FSLIT("GHC.Err")
-gHC_REAL = mkBaseModule FSLIT("GHC.Real")
-gHC_FLOAT = mkBaseModule FSLIT("GHC.Float")
-gHC_TOP_HANDLER = mkBaseModule FSLIT("GHC.TopHandler")
-sYSTEM_IO = mkBaseModule FSLIT("System.IO")
-dYNAMIC = mkBaseModule FSLIT("Data.Dynamic")
-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")
-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")
-rANDOM = mkBaseModule FSLIT("System.Random")
-gLA_EXTS = mkBaseModule FSLIT("GHC.Exts")
-
-nDP_PARRAY = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.PArray")
-nDP_CLOSURE = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Closure")
-nDP_INTERFACE_NAME = mkModuleNameFS FSLIT("Data.Array.Parallel.Lifted")
-nDP_BUILTIN = mkModuleNameFS FSLIT(":NDP")
+gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
+ gHC_MAGIC,
+ gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_CSTRING,
+ gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
+ gHC_HETMET_CODETYPES,
+ gHC_HETMET_PRIVATE,
+ gHC_HETMET_GARROW,
+ gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
+ gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
+ 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, mONAD_GROUP, mONAD_ZIP,
+ aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
+ cONTROL_EXCEPTION_BASE :: Module
+
+gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
+gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
+gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
+gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
+gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
+gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic")
+gHC_CSTRING = mkPrimModule (fsLit "GHC.CString")
+
+gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes")
+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_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
+gHC_HETMET_CODETYPES = mkBaseModule (fsLit "GHC.HetMet.CodeTypes")
+gHC_HETMET_PRIVATE = mkBaseModule (fsLit "GHC.HetMet.Private")
+gHC_HETMET_GARROW = mkBaseModule (fsLit "GHC.HetMet.GArrow")
+gHC_LIST = mkBaseModule (fsLit "GHC.List")
+gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
+dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
+dATA_EITHER = mkBaseModule (fsLit "Data.Either")
+dATA_STRING = mkBaseModule (fsLit "Data.String")
+dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable")
+dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
+gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
+gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
+gHC_IO = mkBaseModule (fsLit "GHC.IO")
+gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
+gHC_ST = mkBaseModule (fsLit "GHC.ST")
+gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
+gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
+gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
+gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
+gHC_ERR = mkBaseModule (fsLit "GHC.Err")
+gHC_REAL = mkBaseModule (fsLit "GHC.Real")
+gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
+gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
+sYSTEM_IO = mkBaseModule (fsLit "System.IO")
+dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
+tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
+gENERICS = mkBaseModule (fsLit "Data.Data")
+dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
+rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
+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")
+mONAD_GROUP = mkBaseModule (fsLit "Control.Monad.Group")
+mONAD_ZIP = mkBaseModule (fsLit "Control.Monad.Zip")
+aRROW = mkBaseModule (fsLit "Control.Arrow")
+cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
+gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
+rANDOM = mkBaseModule (fsLit "System.Random")
+gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
+cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
+
+gHC_PARR :: PackageId -> Module
+gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
+
+gHC_PARR' :: Module
+gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
+
+mAIN, rOOT_MAIN :: Module
mAIN = mkMainModule_ mAIN_NAME
-rOOT_MAIN = mkMainModule FSLIT(":Main") -- Root module for initialisation
+rOOT_MAIN = mkMainModule (fsLit ":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 = mkMainModule FSLIT(":Interactive")
-thFAKE = mkMainModule FSLIT(":THFake")
+iNTERACTIVE :: Module
+iNTERACTIVE = mkMainModule (fsLit ":Interactive")
+
+pRELUDE_NAME, mAIN_NAME :: ModuleName
+pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
+mAIN_NAME = mkModuleNameFS (fsLit "Main")
+
+mkPrimModule :: FastString -> Module
+mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
-pRELUDE_NAME = mkModuleNameFS FSLIT("Prelude")
-mAIN_NAME = mkModuleNameFS FSLIT("Main")
+mkIntegerModule :: FastString -> Module
+mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
mkBaseModule :: FastString -> Module
mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
mkBaseModule_ :: ModuleName -> Module
mkBaseModule_ m = mkModule basePackageId m
-mkNDPModule :: FastString -> Module
-mkNDPModule m = mkModule ndpPackageId (mkModuleNameFS m)
-
-mkNDPModule_ :: ModuleName -> Module
-mkNDPModule_ m = mkModule ndpPackageId m
-
mkMainModule :: FastString -> Module
mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
\begin{code}
mkTupleModule :: Boxity -> Arity -> Module
-mkTupleModule Boxed 0 = gHC_BASE
-mkTupleModule Boxed _ = dATA_TUP
+mkTupleModule Boxed 0 = gHC_UNIT
+mkTupleModule Boxed _ = gHC_TUPLE
mkTupleModule Unboxed _ = gHC_PRIM
\end{code}
%************************************************************************
\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("<=")
-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")
-
+ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
+le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
+lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
+gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
+compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
+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 = varQual_RDR gHC_BASE FSLIT("map")
-append_RDR = varQual_RDR gHC_BASE FSLIT("++")
+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 = nameRdrName andName
-
+left_RDR, right_RDR :: RdrName
left_RDR = nameRdrName leftDataConName
right_RDR = nameRdrName rightDataConName
-fromEnum_RDR = varQual_RDR gHC_ENUM FSLIT("fromEnum")
-toEnum_RDR = varQual_RDR gHC_ENUM FSLIT("toEnum")
+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#")
+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("+")
+times_RDR = varQual_RDR gHC_NUM (fsLit "*")
+plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
+fromString_RDR :: RdrName
fromString_RDR = nameRdrName fromStringName
-compose_RDR = varQual_RDR gHC_BASE FSLIT(".")
-
-not_RDR = varQual_RDR gHC_BASE FSLIT("not")
-getTag_RDR = varQual_RDR gHC_BASE FSLIT("getTag")
-succ_RDR = varQual_RDR gHC_ENUM FSLIT("succ")
-pred_RDR = varQual_RDR gHC_ENUM FSLIT("pred")
-minBound_RDR = varQual_RDR gHC_ENUM FSLIT("minBound")
-maxBound_RDR = varQual_RDR gHC_ENUM FSLIT("maxBound")
-range_RDR = varQual_RDR gHC_ARR FSLIT("range")
-inRange_RDR = varQual_RDR gHC_ARR FSLIT("inRange")
-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 = varQual_RDR gHC_READ FSLIT("readList")
-readListDefault_RDR = varQual_RDR gHC_READ FSLIT("readListDefault")
-readListPrec_RDR = varQual_RDR gHC_READ FSLIT("readListPrec")
-readListPrecDefault_RDR = varQual_RDR gHC_READ FSLIT("readListPrecDefault")
-readPrec_RDR = varQual_RDR gHC_READ FSLIT("readPrec")
-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 = 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 gHC_SHOW FSLIT("showList")
-showList___RDR = varQual_RDR gHC_SHOW FSLIT("showList__")
-showsPrec_RDR = varQual_RDR gHC_SHOW FSLIT("showsPrec")
-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 = varQual_RDR tYPEABLE FSLIT("typeOf")
-mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
-mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
-
-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")
+compose_RDR :: RdrName
+compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
+
+not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
+ and_RDR, range_RDR, inRange_RDR, index_RDR,
+ unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
+and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
+not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
+getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
+succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
+pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
+minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
+maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
+range_RDR = varQual_RDR gHC_ARR (fsLit "range")
+inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
+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")
+readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
+readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
+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")
+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")
+
+error_RDR :: RdrName
+error_RDR = varQual_RDR gHC_ERR (fsLit "error")
+
+-- Old Generics (constructors and functions)
+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")
+
+-- Generics (constructors and functions)
+u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
+ k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
+ prodDataCon_RDR, comp1DataCon_RDR, from_RDR, from1_RDR,
+ to_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR,
+ conFixity_RDR, conIsRecord_RDR,
+ noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
+ prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
+ rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
+
+u1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "U1")
+par1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Par1")
+rec1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
+k1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "K1")
+m1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "M1")
+
+l1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "L1")
+r1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "R1")
+
+prodDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
+comp1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
+
+from_RDR = varQual_RDR gHC_GENERICS (fsLit "from")
+from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
+to_RDR = varQual_RDR gHC_GENERICS (fsLit "to")
+to1_RDR = varQual_RDR gHC_GENERICS (fsLit "to1")
+
+datatypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
+moduleName_RDR = varQual_RDR gHC_GENERICS (fsLit "moduleName")
+selName_RDR = varQual_RDR gHC_GENERICS (fsLit "selName")
+conName_RDR = varQual_RDR gHC_GENERICS (fsLit "conName")
+conFixity_RDR = varQual_RDR gHC_GENERICS (fsLit "conFixity")
+conIsRecord_RDR = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
+
+noArityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
+arityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Arity")
+prefixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
+infixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Infix")
+leftAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
+rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
+notAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
+
+
+fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
+fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
+pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
+ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
+foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
+traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
----------------------
+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)
\begin{code}
-runMainIOName = varQual gHC_TOP_HANDLER FSLIT("runMainIO") runMainKey
-
-orderingTyConName = tcQual gHC_BASE FSLIT("Ordering") orderingTyConKey
-
-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
+wildCardName :: Name
+wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
+
+runMainIOName :: Name
+runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
+
+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 (types)
+v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
+ k1TyConName, m1TyConName, sumTyConName, prodTyConName,
+ compTyConName, rTyConName, pTyConName, dTyConName,
+ cTyConName, sTyConName, rec0TyConName, par0TyConName,
+ d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
+ repTyConName, rep1TyConName :: Name
+
+v1TyConName = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
+u1TyConName = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
+par1TyConName = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
+rec1TyConName = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
+k1TyConName = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
+m1TyConName = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
+
+sumTyConName = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
+prodTyConName = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
+compTyConName = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
+
+rTyConName = tcQual gHC_GENERICS (fsLit "R") rTyConKey
+pTyConName = tcQual gHC_GENERICS (fsLit "P") pTyConKey
+dTyConName = tcQual gHC_GENERICS (fsLit "D") dTyConKey
+cTyConName = tcQual gHC_GENERICS (fsLit "C") cTyConKey
+sTyConName = tcQual gHC_GENERICS (fsLit "S") sTyConKey
+
+rec0TyConName = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
+par0TyConName = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
+d1TyConName = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
+c1TyConName = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
+s1TyConName = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
+noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
+
+repTyConName = tcQual gHC_GENERICS (fsLit "Rep") repTyConKey
+rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
-- Base strings Strings
-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
+unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
+ unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
+unpackCStringName = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
+unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
+unpackCStringFoldrName = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
+unpackCStringUtf8Name = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
+eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
+stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
-- The 'inline' function
-inlineIdName = varQual gHC_BASE FSLIT("inline") inlineIdKey
+inlineIdName :: Name
+inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
-- Base classes (Eq, Ord, Functor)
-eqClassName = clsQual gHC_BASE FSLIT("Eq") eqClassKey
-eqName = methName gHC_BASE FSLIT("==") eqClassOpKey
-ordClassName = clsQual gHC_BASE FSLIT("Ord") ordClassKey
-geName = methName gHC_BASE FSLIT(">=") geClassOpKey
-functorClassName = clsQual gHC_BASE FSLIT("Functor") functorClassKey
+fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
+eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
+eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
+ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
+geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
+functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
+fmapName = methName gHC_BASE (fsLit "fmap") fmapClassOpKey
-- Class Monad
-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
+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
+
+-- Classes (Applicative, Foldable, Traversable)
+applicativeClassName, foldableClassName, traversableClassName :: Name
+applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
+foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey
+traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey
+
+-- Functions for GHC extensions
+groupWithName :: Name
+groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
-- Random PrelBase functions
-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
-appendName = varQual gHC_BASE FSLIT("++") appendIdKey
-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
-
+fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
+ mapName, appendName, assertName,
+ breakpointName, breakpointCondName, breakpointAutoName,
+ dollarName, 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
+dollarName = varQual gHC_BASE (fsLit "$") dollarIdKey
+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"))
+ (mkOccNameFS varName (fsLit "breakpointJump"))
noSrcSpan
+breakpointCondJumpName :: Name
breakpointCondJumpName
= mkInternalName
breakpointCondJumpIdKey
- (mkOccNameFS varName FSLIT("breakpointCondJump"))
+ (mkOccNameFS varName (fsLit "breakpointCondJump"))
noSrcSpan
+breakpointAutoJumpName :: Name
breakpointAutoJumpName
= mkInternalName
breakpointAutoJumpIdKey
- (mkOccNameFS varName FSLIT("breakpointAutoJump"))
+ (mkOccNameFS varName (fsLit "breakpointAutoJump"))
noSrcSpan
-- PrelTup
-fstName = varQual dATA_TUP FSLIT("fst") fstIdKey
-sndName = varQual dATA_TUP FSLIT("snd") sndIdKey
-
--- Module PrelNum
-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
-
--- PrelReal types and classes
-rationalTyConName = tcQual gHC_REAL FSLIT("Rational") rationalTyConKey
-ratioTyConName = tcQual gHC_REAL FSLIT("Ratio") ratioTyConKey
-ratioDataConName = conName gHC_REAL FSLIT(":%") ratioDataConKey
-realClassName = clsQual gHC_REAL FSLIT("Real") realClassKey
-integralClassName = clsQual gHC_REAL FSLIT("Integral") integralClassKey
-realFracClassName = clsQual gHC_REAL FSLIT("RealFrac") realFracClassKey
-fractionalClassName = clsQual gHC_REAL FSLIT("Fractional") fractionalClassKey
-fromRationalName = methName gHC_REAL FSLIT("fromRational") fromRationalClassOpKey
+fstName, sndName :: Name
+fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
+sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
+
+-- Module GHC.Num
+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_INTEGER (fsLit "plusInteger") plusIntegerIdKey
+timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
+integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
+smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
+
+-- GHC.Real types and classes
+rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
+ integralClassName, realFracClassName, fractionalClassName,
+ fromRationalName, toIntegerName, toRationalName, fromIntegralName,
+ realToFracName :: Name
+rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
+ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
+ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
+realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
+integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
+realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
+fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
+fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
+toIntegerName = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
+toRationalName = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
+fromIntegralName = varQual gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
+realToFracName = varQual gHC_REAL (fsLit "realToFrac") realToFracIdKey
-- PrelFloat classes
-floatingClassName = clsQual gHC_FLOAT FSLIT("Floating") floatingClassKey
-realFloatClassName = clsQual gHC_FLOAT FSLIT("RealFloat") realFloatClassKey
+floatingClassName, realFloatClassName :: Name
+floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
+realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
-- Class Ix
-ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey
+ixClassName :: Name
+ixClassName = clsQual gHC_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
-
+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
+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 :: [Name]
typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
, typeable3ClassName, typeable4ClassName, typeable5ClassName
, typeable6ClassName, typeable7ClassName ]
-- Class Data
-dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
+dataClassName :: Name
+dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
-- Error module
-assertErrorName = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey
+assertErrorName :: Name
+assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
-- Enum module (Enum, Bounded)
-enumClassName = clsQual gHC_ENUM FSLIT("Enum") enumClassKey
-enumFromName = methName gHC_ENUM FSLIT("enumFrom") enumFromClassOpKey
-enumFromToName = methName gHC_ENUM FSLIT("enumFromTo") enumFromToClassOpKey
-enumFromThenName = methName gHC_ENUM FSLIT("enumFromThen") enumFromThenClassOpKey
-enumFromThenToName = methName gHC_ENUM FSLIT("enumFromThenTo") enumFromThenToClassOpKey
-boundedClassName = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey
+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
+enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
+enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
+boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
-- List functions
-concatName = varQual gHC_LIST FSLIT("concat") concatIdKey
-filterName = varQual gHC_LIST FSLIT("filter") filterIdKey
-zipName = varQual gHC_LIST FSLIT("zip") zipIdKey
+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 = clsQual gHC_SHOW FSLIT("Show") showClassKey
+showClassName :: Name
+showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
-- Class Read
-readClassName = clsQual gHC_READ FSLIT("Read") readClassKey
+readClassName :: Name
+readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
+
+-- Classes Generic and Generic1, Datatype, Constructor and Selector
+genClassName, gen1ClassName, datatypeClassName, constructorClassName,
+ selectorClassName :: Name
+genClassName = clsQual gHC_GENERICS (fsLit "Generic") genClassKey
+gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
+
+datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
+constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
+selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
-- parallel array types and functions
-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
-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
-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
-bpermuteDftPName = varQual gHC_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey
-indexOfPName = varQual gHC_PARR FSLIT("indexOfP") indexOfPIdKey
-
--- IOBase things
-ioTyConName = tcQual gHC_IO_BASE FSLIT("IO") ioTyConKey
-ioDataConName = conName gHC_IO_BASE FSLIT("IO") ioDataConKey
-thenIOName = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey
-bindIOName = varQual gHC_IO_BASE FSLIT("bindIO") bindIOIdKey
-returnIOName = varQual gHC_IO_BASE FSLIT("returnIO") returnIOIdKey
-failIOName = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey
+enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
+ singletonPName, replicatePName, mapPName, filterPName,
+ zipPName, crossMapPName, indexPName, toPName,
+ emptyPName, appPName :: PackageId -> Name
+enumFromToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP") enumFromToPIdKey
+enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey
+nullPName pkg = varQual (gHC_PARR pkg) (fsLit "nullP") nullPIdKey
+lengthPName pkg = varQual (gHC_PARR pkg) (fsLit "lengthP") lengthPIdKey
+singletonPName pkg = varQual (gHC_PARR pkg) (fsLit "singletonP") singletonPIdKey
+replicatePName pkg = varQual (gHC_PARR pkg) (fsLit "replicateP") replicatePIdKey
+mapPName pkg = varQual (gHC_PARR pkg) (fsLit "mapP") mapPIdKey
+filterPName pkg = varQual (gHC_PARR pkg) (fsLit "filterP") filterPIdKey
+zipPName pkg = varQual (gHC_PARR pkg) (fsLit "zipP") zipPIdKey
+crossMapPName pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP") crossMapPIdKey
+indexPName pkg = varQual (gHC_PARR pkg) (fsLit "!:") indexPIdKey
+toPName pkg = varQual (gHC_PARR pkg) (fsLit "toP") toPIdKey
+emptyPName pkg = varQual (gHC_PARR pkg) (fsLit "emptyP") emptyPIdKey
+appPName pkg = varQual (gHC_PARR pkg) (fsLit "+:+") appPIdKey
+
+-- code type things
+hetmet_brak_name, hetmet_esc_name, hetmet_csp_name, hetmet_flatten_name, hetmet_unflatten_name, hetmet_flattened_id_name :: Name
+hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name, hetmet_guest_char_literal_name :: Name
+hetmet_brak_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_brak") hetmet_brak_key
+hetmet_esc_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_esc") hetmet_esc_key
+hetmet_csp_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_csp") hetmet_csp_key
+hetmet_flatten_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_flatten") hetmet_flatten_key
+hetmet_unflatten_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_unflatten") hetmet_unflatten_key
+hetmet_flattened_id_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_flattened_id") hetmet_flattened_id_key
+hetmet_guest_integer_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestIntegerLiteral") hetmet_guest_integer_literal_key
+hetmet_guest_string_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestStringLiteral") hetmet_guest_string_literal_key
+hetmet_guest_char_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestCharLiteral") hetmet_guest_char_literal_key
+
+hetmet_PGArrow_name :: Name
+hetmet_PGArrow_name = tcQual gHC_HETMET_PRIVATE (fsLit "PGArrow") hetmet_PGArrow_key
+hetmet_PGArrow_unit_name :: Name
+hetmet_PGArrow_unit_name = tcQual gHC_HETMET_GARROW (fsLit "GArrowUnit") hetmet_PGArrow_unit_key
+hetmet_PGArrow_tensor_name :: Name
+hetmet_PGArrow_tensor_name = tcQual gHC_HETMET_GARROW (fsLit "GArrowTensor") hetmet_PGArrow_tensor_key
+hetmet_PGArrow_exponent_name :: Name
+hetmet_PGArrow_exponent_name = tcQual gHC_HETMET_GARROW (fsLit "GArrowExponent") hetmet_PGArrow_exponent_key
+hetmet_pga_id_name :: Name
+hetmet_pga_id_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_id") hetmet_pga_id_key
+hetmet_pga_comp_name :: Name
+hetmet_pga_comp_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_comp") hetmet_pga_comp_key
+hetmet_pga_first_name :: Name
+hetmet_pga_first_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_first") hetmet_pga_first_key
+hetmet_pga_second_name :: Name
+hetmet_pga_second_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_second") hetmet_pga_second_key
+hetmet_pga_cancell_name :: Name
+hetmet_pga_cancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancell") hetmet_pga_cancell_key
+hetmet_pga_cancelr_name :: Name
+hetmet_pga_cancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancelr") hetmet_pga_cancelr_key
+hetmet_pga_uncancell_name :: Name
+hetmet_pga_uncancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancell") hetmet_pga_uncancell_key
+hetmet_pga_uncancelr_name :: Name
+hetmet_pga_uncancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancelr") hetmet_pga_uncancelr_key
+hetmet_pga_assoc_name :: Name
+hetmet_pga_assoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_assoc") hetmet_pga_assoc_key
+hetmet_pga_unassoc_name :: Name
+hetmet_pga_unassoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_unassoc") hetmet_pga_unassoc_key
+hetmet_pga_copy_name :: Name
+hetmet_pga_copy_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_copy") hetmet_pga_copy_key
+hetmet_pga_drop_name :: Name
+hetmet_pga_drop_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_drop") hetmet_pga_drop_key
+hetmet_pga_swap_name :: Name
+hetmet_pga_swap_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_swap") hetmet_pga_swap_key
+hetmet_pga_applyl_name :: Name
+hetmet_pga_applyl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyl") hetmet_pga_applyl_key
+hetmet_pga_applyr_name :: Name
+hetmet_pga_applyr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyr") hetmet_pga_applyr_key
+hetmet_pga_curryl_name :: Name
+hetmet_pga_curryl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryl") hetmet_pga_curryl_key
+hetmet_pga_curryr_name :: Name
+hetmet_pga_curryr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryr") hetmet_pga_curryr_key
+
+-- IO things
+ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
+ failIOName :: Name
+ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey
+ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey
+thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
+bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
+returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
+failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey
-- IO things
-printName = varQual sYSTEM_IO FSLIT("print") printIdKey
+printName :: Name
+printName = varQual sYSTEM_IO (fsLit "print") printIdKey
-- Int, Word, and Addr things
-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
+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 = tcQual gHC_WORD FSLIT("Word8") word8TyConKey
-word16TyConName = tcQual gHC_WORD FSLIT("Word16") word16TyConKey
-word32TyConName = tcQual gHC_WORD FSLIT("Word32") word32TyConKey
-word64TyConName = tcQual gHC_WORD FSLIT("Word64") word64TyConKey
-wordTyConName = tcQual gHC_WORD FSLIT("Word") wordTyConKey
-wordDataConName = conName gHC_WORD FSLIT("W#") wordDataConKey
+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
+word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
+wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
+wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
-- PrelPtr module
-ptrTyConName = tcQual gHC_PTR FSLIT("Ptr") ptrTyConKey
-funPtrTyConName = tcQual gHC_PTR FSLIT("FunPtr") funPtrTyConKey
+ptrTyConName, funPtrTyConName :: Name
+ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
+funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
-- Foreign objects and weak pointers
-stablePtrTyConName = tcQual gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey
-newStablePtrName = varQual gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey
+stablePtrTyConName, newStablePtrName :: Name
+stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
+newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
-- PrelST module
-runSTRepName = varQual gHC_ST FSLIT("runSTRep") runSTRepIdKey
+runSTRepName :: Name
+runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
-- Recursive-do notation
-monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
-mfixName = methName mONAD_FIX FSLIT("mfix") mfixIdKey
+monadFixClassName, mfixName :: Name
+monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
+mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
-- Arrow notation
-arrAName = varQual aRROW FSLIT("arr") arrAIdKey
-composeAName = varQual aRROW FSLIT(">>>") composeAIdKey
-firstAName = varQual aRROW FSLIT("first") firstAIdKey
-appAName = varQual aRROW FSLIT("app") appAIdKey
-choiceAName = varQual aRROW FSLIT("|||") choiceAIdKey
-loopAName = varQual aRROW FSLIT("loop") loopAIdKey
+arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
+arrAName = varQual aRROW (fsLit "arr") arrAIdKey
+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
+
+-- Monad comprehensions
+guardMName, liftMName, groupMName, mzipName :: Name
+guardMName = varQual mONAD (fsLit "guard") guardMIdKey
+liftMName = varQual mONAD (fsLit "liftM") liftMIdKey
+groupMName = varQual mONAD_GROUP (fsLit "mgroupWith") groupMIdKey
+mzipName = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
+
+
+-- Annotation type checking
+toAnnotationWrapperName :: Name
+toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
-- Other classes, needed for type defaulting
-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
+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 = tcQual dOTNET FSLIT("Object") objectTyConKey
+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 = 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
-
--- NDP stuff
-parrayTyConName = tcQual nDP_PARRAY FSLIT("PArray") parrayTyConKey
-paTyConName = tcQual nDP_PARRAY FSLIT("PA") paTyConKey
-lengthPAName = varQual nDP_PARRAY FSLIT("lengthPA") lengthPAIdKey
-replicatePAName = varQual nDP_PARRAY FSLIT("replicatePA") replicatePAIdKey
-emptyPAName = varQual nDP_PARRAY FSLIT("emptyPA") emptyPAIdKey
-closureTyConName = tcQual nDP_CLOSURE FSLIT(":->") closureTyConKey
-mkClosureName = varQual nDP_CLOSURE FSLIT("mkClosure") mkClosureIdKey
-applyClosureName = varQual nDP_CLOSURE FSLIT("$:") applyClosureIdKey
-mkClosurePName = varQual nDP_CLOSURE FSLIT("mkClosureP") mkClosurePIdKey
-applyClosurePName = varQual nDP_CLOSURE FSLIT("$:^") applyClosurePIdKey
+unmarshalObjectName, marshalObjectName, marshalStringName,
+ unmarshalStringName, checkDotnetResName :: Name
+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, 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) noSrcSpan
+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) noSrcSpan
+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) noSrcSpan
+methName modu occ unique
+ = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
\end{code}
%************************************************************************
--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
showClassKey = mkPreludeClassUnique 17
ixClassKey = mkPreludeClassUnique 18
+typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
+ typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
+ :: Unique
typeableClassKey = mkPreludeClassUnique 20
typeable1ClassKey = mkPreludeClassUnique 21
typeable2ClassKey = mkPreludeClassUnique 22
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
+
+applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
+applicativeClassKey = mkPreludeClassUnique 34
+foldableClassKey = mkPreludeClassUnique 35
+traversableClassKey = mkPreludeClassUnique 36
+
+genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
+ selectorClassKey :: Unique
+genClassKey = mkPreludeClassUnique 37
+gen1ClassKey = mkPreludeClassUnique 38
+
+datatypeClassKey = mkPreludeClassUnique 39
+constructorClassKey = mkPreludeClassUnique 40
+selectorClassKey = mkPreludeClassUnique 41
\end{code}
%************************************************************************
%************************************************************************
\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,
+ anyTyConKey :: Unique
addrPrimTyConKey = mkPreludeTyConUnique 1
arrayPrimTyConKey = mkPreludeTyConUnique 3
boolTyConKey = mkPreludeTyConUnique 4
realWorldTyConKey = mkPreludeTyConUnique 34
stablePtrPrimTyConKey = mkPreludeTyConUnique 35
stablePtrTyConKey = mkPreludeTyConUnique 36
-
-anyPrimTyConKey = mkPreludeTyConUnique 37
-anyPrimTyCon1Key = mkPreludeTyConUnique 38
-
+anyTyConKey = mkPreludeTyConUnique 37
+
+statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
+ mutVarPrimTyConKey, ioTyConKey,
+ wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
+ word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
+ liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
+ typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
+ funPtrTyConKey, tVarPrimTyConKey, eqPredPrimTyConKey :: Unique
statePrimTyConKey = mkPreludeTyConUnique 50
stableNamePrimTyConKey = mkPreludeTyConUnique 51
-stableNameTyConKey = mkPreludeTyConUnique 52
-mutVarPrimTyConKey = mkPreludeTyConUnique 55
+stableNameTyConKey = mkPreludeTyConUnique 52
+eqPredPrimTyConKey = mkPreludeTyConUnique 53
+mutVarPrimTyConKey = mkPreludeTyConUnique 55
ioTyConKey = mkPreludeTyConUnique 56
wordPrimTyConKey = mkPreludeTyConUnique 58
wordTyConKey = mkPreludeTyConUnique 59
funPtrTyConKey = mkPreludeTyConUnique 75
tVarPrimTyConKey = mkPreludeTyConUnique 76
--- Generic Type Constructors
-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 :: Unique
tySuperKindTyConKey = mkPreludeTyConUnique 85
-coSuperKindTyConKey = mkPreludeTyConUnique 86
-- Kind constructors
+liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
+ ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
liftedTypeKindTyConKey = mkPreludeTyConUnique 87
openTypeKindTyConKey = mkPreludeTyConUnique 88
unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
argTypeKindTyConKey = mkPreludeTyConUnique 91
-- Coercion constructors
+symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
+ rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
+ csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
+ :: Unique
symCoercionTyConKey = mkPreludeTyConUnique 93
transCoercionTyConKey = mkPreludeTyConUnique 94
leftCoercionTyConKey = mkPreludeTyConUnique 95
rightCoercionTyConKey = mkPreludeTyConUnique 96
instCoercionTyConKey = mkPreludeTyConUnique 97
unsafeCoercionTyConKey = mkPreludeTyConUnique 98
+csel1CoercionTyConKey = mkPreludeTyConUnique 99
+csel2CoercionTyConKey = mkPreludeTyConUnique 100
+cselRCoercionTyConKey = mkPreludeTyConUnique 101
-unknownTyConKey = mkPreludeTyConUnique 99
+unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
+ opaqueTyConKey :: Unique
+unknownTyConKey = mkPreludeTyConUnique 129
unknown1TyConKey = mkPreludeTyConUnique 130
unknown2TyConKey = mkPreludeTyConUnique 131
unknown3TyConKey = mkPreludeTyConUnique 132
opaqueTyConKey = mkPreludeTyConUnique 133
+stringTyConKey :: Unique
stringTyConKey = mkPreludeTyConUnique 134
-parrayTyConKey = mkPreludeTyConUnique 135
-closureTyConKey = mkPreludeTyConUnique 136
-paTyConKey = mkPreludeTyConUnique 137
-
+-- Generics (Unique keys)
+v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
+ k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
+ compTyConKey, rTyConKey, pTyConKey, dTyConKey,
+ cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
+ d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
+ repTyConKey, rep1TyConKey :: Unique
+
+v1TyConKey = mkPreludeTyConUnique 135
+u1TyConKey = mkPreludeTyConUnique 136
+par1TyConKey = mkPreludeTyConUnique 137
+rec1TyConKey = mkPreludeTyConUnique 138
+k1TyConKey = mkPreludeTyConUnique 139
+m1TyConKey = mkPreludeTyConUnique 140
+
+sumTyConKey = mkPreludeTyConUnique 141
+prodTyConKey = mkPreludeTyConUnique 142
+compTyConKey = mkPreludeTyConUnique 143
+
+rTyConKey = mkPreludeTyConUnique 144
+pTyConKey = mkPreludeTyConUnique 145
+dTyConKey = mkPreludeTyConUnique 146
+cTyConKey = mkPreludeTyConUnique 147
+sTyConKey = mkPreludeTyConUnique 148
+
+rec0TyConKey = mkPreludeTyConUnique 149
+par0TyConKey = mkPreludeTyConUnique 150
+d1TyConKey = mkPreludeTyConUnique 151
+c1TyConKey = mkPreludeTyConUnique 152
+s1TyConKey = mkPreludeTyConUnique 153
+noSelTyConKey = mkPreludeTyConUnique 154
+
+repTyConKey = mkPreludeTyConUnique 155
+rep1TyConKey = mkPreludeTyConUnique 156
+>>>>>>> 18691d440f90a3dff4ef538091c886af505e5cf5
---------------- Template Haskell -------------------
--- USES TyConUniques 100-129
+-- USES TyConUniques 200-299
-----------------------------------------------------
+unitTyConKey :: Unique
unitTyConKey = mkTupleTyConUnique Boxed 0
\end{code}
%************************************************************************
\begin{code}
+charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
+ floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
+ stableNameDataConKey, trueDataConKey, wordDataConKey,
+ ioDataConKey, integerDataConKey :: 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
trueDataConKey = mkPreludeDataConUnique 15
wordDataConKey = mkPreludeDataConUnique 16
ioDataConKey = mkPreludeDataConUnique 17
+integerDataConKey = mkPreludeDataConUnique 18
-- 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
+
+-- Data constructor for Heterogeneous Metaprogramming code types
+hetMetCodeTypeDataConKey :: Unique
+hetMetCodeTypeDataConKey = mkPreludeDataConUnique 27
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-absentErrorIdKey = mkPreludeMiscIdUnique 1
+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, wildCardKey,
+ unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
+ unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
+wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard]
+absentErrorIdKey = mkPreludeMiscIdUnique 1
augmentIdKey = mkPreludeMiscIdUnique 3
appendIdKey = mkPreludeMiscIdUnique 4
buildIdKey = mkPreludeMiscIdUnique 5
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
returnIOIdKey = mkPreludeMiscIdUnique 37
deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
newStablePtrIdKey = mkPreludeMiscIdUnique 39
+smallIntegerIdKey = mkPreludeMiscIdUnique 40
plusIntegerIdKey = mkPreludeMiscIdUnique 41
timesIntegerIdKey = mkPreludeMiscIdUnique 42
printIdKey = mkPreludeMiscIdUnique 43
assertIdKey = mkPreludeMiscIdUnique 53
runSTRepIdKey = mkPreludeMiscIdUnique 54
+rootMainKey, runMainKey :: Unique
rootMainKey = mkPreludeMiscIdUnique 55
runMainKey = mkPreludeMiscIdUnique 56
-andIdKey = mkPreludeMiscIdUnique 57
-orIdKey = mkPreludeMiscIdUnique 58
+thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
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
breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
+inlineIdKey :: Unique
inlineIdKey = mkPreludeMiscIdUnique 68
+mapIdKey, groupWithIdKey, dollarIdKey :: Unique
+mapIdKey = mkPreludeMiscIdUnique 69
+groupWithIdKey = mkPreludeMiscIdUnique 70
+dollarIdKey = mkPreludeMiscIdUnique 71
+
+coercionTokenIdKey :: Unique
+coercionTokenIdKey = mkPreludeMiscIdUnique 72
+
-- Parallel array functions
+singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
+ filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
+ enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
+singletonPIdKey = mkPreludeMiscIdUnique 79
nullPIdKey = mkPreludeMiscIdUnique 80
lengthPIdKey = mkPreludeMiscIdUnique 81
replicatePIdKey = mkPreludeMiscIdUnique 82
toPIdKey = mkPreludeMiscIdUnique 88
enumFromToPIdKey = mkPreludeMiscIdUnique 89
enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
-bpermutePIdKey = mkPreludeMiscIdUnique 91
-bpermuteDftPIdKey = mkPreludeMiscIdUnique 92
-indexOfPIdKey = mkPreludeMiscIdUnique 93
+emptyPIdKey = mkPreludeMiscIdUnique 91
+appPIdKey = mkPreludeMiscIdUnique 92
-- dotnet interop
+unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
+ unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
marshalObjectIdKey = mkPreludeMiscIdUnique 95
marshalStringIdKey = mkPreludeMiscIdUnique 96
\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,
+ fmapClassOpKey
+ :: Unique
fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
minusClassOpKey = mkPreludeMiscIdUnique 103
fromRationalClassOpKey = mkPreludeMiscIdUnique 104
failMClassOpKey = mkPreludeMiscIdUnique 112
bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
+fmapClassOpKey = mkPreludeMiscIdUnique 115
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
choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
loopAIdKey = mkPreludeMiscIdUnique 124
+fromStringClassOpKey :: Unique
fromStringClassOpKey = mkPreludeMiscIdUnique 125
--- Flattened parallel array functions
-mkClosureIdKey = mkPreludeMiscIdUnique 126
-applyClosureIdKey = mkPreludeMiscIdUnique 127
-mkClosurePIdKey = mkPreludeMiscIdUnique 128
-applyClosurePIdKey = mkPreludeMiscIdUnique 129
-closurePAIdKey = mkPreludeMiscIdUnique 130
-lengthPAIdKey = mkPreludeMiscIdUnique 131
-replicatePAIdKey = mkPreludeMiscIdUnique 132
-emptyPAIdKey = mkPreludeMiscIdUnique 133
+-- Annotation type checking
+toAnnotationWrapperIdKey :: Unique
+toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
+
+-- Conversion functions
+fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
+fromIntegralIdKey = mkPreludeMiscIdUnique 127
+realToFracIdKey = mkPreludeMiscIdUnique 128
+toIntegerClassOpKey = mkPreludeMiscIdUnique 129
+toRationalClassOpKey = mkPreludeMiscIdUnique 130
+
+-- Monad comprehensions
+guardMIdKey, liftMIdKey, groupMIdKey, mzipIdKey :: Unique
+guardMIdKey = mkPreludeMiscIdUnique 131
+liftMIdKey = mkPreludeMiscIdUnique 132
+groupMIdKey = mkPreludeMiscIdUnique 133
+mzipIdKey = mkPreludeMiscIdUnique 134
+
+-- code types
+hetMetCodeTypeTyConKey :: Unique
+hetMetCodeTypeTyConKey = mkPreludeTyConUnique 135
+
+hetmet_guest_integer_literal_key, hetmet_guest_string_literal_key, hetmet_guest_char_literal_key :: Unique
+hetmet_guest_integer_literal_key = mkPreludeMiscIdUnique 134
+hetmet_guest_string_literal_key = mkPreludeMiscIdUnique 135
+hetmet_guest_char_literal_key = mkPreludeMiscIdUnique 136
+hetmet_PGArrow_key :: Unique
+hetmet_PGArrow_key = mkPreludeMiscIdUnique 137
+hetmet_pga_id_key :: Unique
+hetmet_pga_id_key = mkPreludeMiscIdUnique 138
+hetmet_pga_comp_key :: Unique
+hetmet_pga_comp_key = mkPreludeMiscIdUnique 139
+hetmet_pga_first_key :: Unique
+hetmet_pga_first_key = mkPreludeMiscIdUnique 140
+hetmet_pga_second_key :: Unique
+hetmet_pga_second_key = mkPreludeMiscIdUnique 141
+hetmet_pga_cancell_key :: Unique
+hetmet_pga_cancell_key = mkPreludeMiscIdUnique 142
+hetmet_pga_cancelr_key :: Unique
+hetmet_pga_cancelr_key = mkPreludeMiscIdUnique 143
+hetmet_pga_uncancell_key :: Unique
+hetmet_pga_uncancell_key = mkPreludeMiscIdUnique 144
+hetmet_pga_uncancelr_key :: Unique
+hetmet_pga_uncancelr_key = mkPreludeMiscIdUnique 145
+hetmet_pga_assoc_key :: Unique
+hetmet_pga_assoc_key = mkPreludeMiscIdUnique 146
+hetmet_pga_unassoc_key :: Unique
+hetmet_pga_unassoc_key = mkPreludeMiscIdUnique 147
+hetmet_pga_copy_key :: Unique
+hetmet_pga_copy_key = mkPreludeMiscIdUnique 148
+hetmet_pga_drop_key :: Unique
+hetmet_pga_drop_key = mkPreludeMiscIdUnique 149
+hetmet_pga_swap_key :: Unique
+hetmet_pga_swap_key = mkPreludeMiscIdUnique 150
+hetmet_pga_applyl_key :: Unique
+hetmet_pga_applyl_key = mkPreludeMiscIdUnique 151
+hetmet_pga_applyr_key :: Unique
+hetmet_pga_applyr_key = mkPreludeMiscIdUnique 152
+hetmet_pga_curryl_key :: Unique
+hetmet_pga_curryl_key = mkPreludeMiscIdUnique 153
+hetmet_pga_curryr_key :: Unique
+hetmet_pga_curryr_key = mkPreludeMiscIdUnique 154
+hetmet_flatten_key = mkPreludeMiscIdUnique 155
+hetmet_unflatten_key = mkPreludeMiscIdUnique 156
+hetmet_flattened_id_key = mkPreludeMiscIdUnique 157
+hetmet_PGArrow_unit_key :: Unique
+hetmet_PGArrow_unit_key = mkPreludeMiscIdUnique 158
+hetmet_PGArrow_tensor_key :: Unique
+hetmet_PGArrow_tensor_key = mkPreludeMiscIdUnique 159
+hetmet_PGArrow_exponent_key :: Unique
+hetmet_PGArrow_exponent_key = mkPreludeMiscIdUnique 160
+
+hetmet_brak_key, hetmet_esc_key, hetmet_csp_key, hetmet_flatten_key, hetmet_unflatten_key, hetmet_flattened_id_key :: Unique
+hetmet_brak_key = mkPreludeMiscIdUnique 161
+hetmet_esc_key = mkPreludeMiscIdUnique 162
+hetmet_csp_key = mkPreludeMiscIdUnique 163
+
---------------- Template Haskell -------------------
--- USES IdUniques 200-399
+-- USES IdUniques 200-499
-----------------------------------------------------
\end{code}
%************************************************************************
\begin{code}
-numericTyKeys =
+numericTyKeys :: [Unique]
+numericTyKeys =
[ wordTyConKey
, intTyConKey
, integerTyConKey
, doubleTyConKey
, floatTyConKey
]
+
+kindKeys :: [Unique]
+kindKeys = [ liftedTypeKindTyConKey
+ , openTypeKindTyConKey
+ , unliftedTypeKindTyConKey
+ , ubxTupleKindTyConKey
+ , argTypeKindTyConKey ]
\end{code}
because the list of ambiguous dictionaries hasn't been simplified.
\begin{code}
+numericClassKeys :: [Unique]
numericClassKeys =
[ numClassKey
, realClassKey
]
++ fractionalClassKeys
+fractionalClassKeys :: [Unique]
fractionalClassKeys =
[ fractionalClassKey
, floatingClassKey
-- 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,
- isStringClassKey
+ isStringClassKey,
+ applicativeClassKey, foldableClassKey, traversableClassKey
]
\end{code}
(@TcDeriv@).
\begin{code}
+derivableClassKeys :: [Unique]
derivableClassKeys
= [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
boundedClassKey, showClassKey, readClassKey ]
projects / ghc-hetmet.git / blobdiff