\begin{code}
-{-# OPTIONS -w #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and fix
--- any warnings in the module. See
--- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
--- for details
-
module PrelNames (
Unique, Uniquable(..), hasKey, -- Re-exported for convenience
#include "HsVersions.h"
import Module
-import OccName ( dataName, tcName, clsName, varName, tvName,
- mkOccNameFS, mkVarOccFS )
+import OccName
import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
import Unique ( Unique, Uniquable(..), hasKey,
mkPreludeMiscIdUnique, mkPreludeDataConUnique,
This *local* name is used by the interactive stuff
\begin{code}
+itName :: Unique -> Name
itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcSpan
\end{code}
--MetaHaskell Extension Add a new module here
\begin{code}
+pRELUDE :: Module
pRELUDE = mkBaseModule_ pRELUDE_NAME
+
+gHC_PRIM, gHC_BOOL, gHC_GENERICS, gHC_BASE, gHC_ENUM, gHC_SHOW, gHC_READ,
+ gHC_NUM, gHC_INTEGER, gHC_LIST, gHC_PARR, dATA_TUP, dATA_EITHER,
+ dATA_STRING, gHC_PACK, gHC_CONC, gHC_IO_BASE, gHC_ST, gHC_ARR,
+ gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL, gHC_FLOAT,
+ gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS, dOTNET,
+ rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW,
+ gHC_DESUGAR, rANDOM, gHC_EXTS :: Module
gHC_PRIM = mkPrimModule FSLIT("GHC.Prim") -- Primitive types and values
gHC_BOOL = mkPrimModule FSLIT("GHC.Bool")
gHC_ORDERING = mkPrimModule FSLIT("GHC.Ordering")
rANDOM = mkBaseModule FSLIT("System.Random")
gHC_EXTS = mkBaseModule FSLIT("GHC.Exts")
+mAIN, rOOT_MAIN :: Module
mAIN = mkMainModule_ mAIN_NAME
rOOT_MAIN = mkMainModule FSLIT(":Main") -- Root module for initialisation
-- use himself. The z-encoding for ':' is "ZC", so the z-encoded
-- module name still starts with a capital letter, which keeps
-- the z-encoded version consistent.
+iNTERACTIVE, thFAKE :: Module
iNTERACTIVE = mkMainModule FSLIT(":Interactive")
thFAKE = mkMainModule FSLIT(":THFake")
+pRELUDE_NAME, mAIN_NAME :: ModuleName
pRELUDE_NAME = mkModuleNameFS FSLIT("Prelude")
mAIN_NAME = mkModuleNameFS FSLIT("Main")
%************************************************************************
\begin{code}
+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 = 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("/=")
eqTag_RDR = dataQual_RDR gHC_ORDERING FSLIT("EQ")
gtTag_RDR = dataQual_RDR gHC_ORDERING FSLIT("GT")
+eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
+ :: RdrName
eqClass_RDR = nameRdrName eqClassName
numClass_RDR = nameRdrName numClassName
ordClass_RDR = nameRdrName ordClassName
enumClass_RDR = nameRdrName enumClassName
monadClass_RDR = nameRdrName monadClassName
+map_RDR, append_RDR :: RdrName
map_RDR = varQual_RDR gHC_BASE FSLIT("map")
append_RDR = varQual_RDR gHC_BASE FSLIT("++")
+foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
foldr_RDR = nameRdrName foldrName
build_RDR = nameRdrName buildName
returnM_RDR = nameRdrName returnMName
bindM_RDR = nameRdrName bindMName
failM_RDR = nameRdrName failMName
+and_RDR :: RdrName
and_RDR = nameRdrName andName
+left_RDR, right_RDR :: RdrName
left_RDR = nameRdrName leftDataConName
right_RDR = nameRdrName rightDataConName
+fromEnum_RDR, toEnum_RDR :: RdrName
fromEnum_RDR = varQual_RDR gHC_ENUM FSLIT("fromEnum")
toEnum_RDR = varQual_RDR gHC_ENUM FSLIT("toEnum")
+enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
enumFrom_RDR = nameRdrName enumFromName
enumFromTo_RDR = nameRdrName enumFromToName
enumFromThen_RDR = nameRdrName enumFromThenName
enumFromThenTo_RDR = nameRdrName enumFromThenToName
+ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
ratioDataCon_RDR = nameRdrName ratioDataConName
plusInteger_RDR = nameRdrName plusIntegerName
timesInteger_RDR = nameRdrName timesIntegerName
+ioDataCon_RDR :: RdrName
ioDataCon_RDR = nameRdrName ioDataConName
+eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
+ unpackCStringUtf8_RDR :: RdrName
eqString_RDR = nameRdrName eqStringName
unpackCString_RDR = nameRdrName unpackCStringName
unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
+newStablePtr_RDR, wordDataCon_RDR :: RdrName
newStablePtr_RDR = nameRdrName newStablePtrName
wordDataCon_RDR = dataQual_RDR gHC_WORD FSLIT("W#")
+bindIO_RDR, returnIO_RDR :: RdrName
bindIO_RDR = nameRdrName bindIOName
returnIO_RDR = nameRdrName returnIOName
+fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
fromInteger_RDR = nameRdrName fromIntegerName
fromRational_RDR = nameRdrName fromRationalName
minus_RDR = nameRdrName minusName
times_RDR = varQual_RDR gHC_NUM FSLIT("*")
plus_RDR = varQual_RDR gHC_NUM FSLIT("+")
+fromString_RDR :: RdrName
fromString_RDR = nameRdrName fromStringName
+compose_RDR :: RdrName
compose_RDR = varQual_RDR gHC_BASE FSLIT(".")
+not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
+ range_RDR, inRange_RDR, index_RDR,
+ unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
not_RDR = varQual_RDR gHC_BASE FSLIT("not")
getTag_RDR = varQual_RDR gHC_BASE FSLIT("getTag")
succ_RDR = varQual_RDR gHC_ENUM FSLIT("succ")
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")
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")
showSpace_RDR = varQual_RDR gHC_SHOW FSLIT("showSpace")
showParen_RDR = varQual_RDR gHC_SHOW FSLIT("showParen")
+typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
typeOf_RDR = varQual_RDR tYPEABLE FSLIT("typeOf")
mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
+undefined_RDR :: RdrName
undefined_RDR = varQual_RDR gHC_ERR FSLIT("undefined")
+crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
crossDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT(":*:")
inlDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Inl")
inrDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Inr")
genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Unit")
----------------------
+varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
+ :: Module -> FastString -> RdrName
varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
\begin{code}
+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
+crossTyConName, plusTyConName, genUnitTyConName :: Name
crossTyConName = tcQual gHC_GENERICS FSLIT(":*:") crossTyConKey
plusTyConName = tcQual gHC_GENERICS FSLIT(":+:") plusTyConKey
genUnitTyConName = tcQual gHC_GENERICS FSLIT("Unit") genUnitTyConKey
-- Base strings Strings
+unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
+ unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
unpackCStringName = varQual gHC_BASE FSLIT("unpackCString#") unpackCStringIdKey
unpackCStringAppendName = varQual gHC_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey
unpackCStringFoldrName = varQual gHC_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
stringTyConName = tcQual gHC_BASE FSLIT("String") stringTyConKey
-- The 'inline' function
+inlineIdName :: Name
inlineIdName = varQual gHC_BASE FSLIT("inline") inlineIdKey
-- Base classes (Eq, Ord, Functor)
+eqClassName, eqName, ordClassName, geName, functorClassName :: Name
eqClassName = clsQual gHC_BASE FSLIT("Eq") eqClassKey
eqName = methName gHC_BASE FSLIT("==") eqClassOpKey
ordClassName = clsQual gHC_BASE FSLIT("Ord") ordClassKey
functorClassName = clsQual gHC_BASE FSLIT("Functor") functorClassKey
-- Class Monad
+monadClassName, thenMName, bindMName, returnMName, failMName :: Name
monadClassName = clsQual gHC_BASE FSLIT("Monad") monadClassKey
thenMName = methName gHC_BASE FSLIT(">>") thenMClassOpKey
bindMName = methName gHC_BASE FSLIT(">>=") bindMClassOpKey
failMName = methName gHC_BASE FSLIT("fail") failMClassOpKey
-- Functions for GHC extensions
-groupWithName = varQual gHC_EXTS FSLIT("groupWith") groupWithIdKey
+groupWithName :: Name
+groupWithName = varQual gHC_EXTS FSLIT("groupWith") groupWithIdKey
-- Random PrelBase functions
+fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
+ mapName, appendName, andName, orName, assertName,
+ breakpointName, breakpointCondName, breakpointAutoName,
+ opaqueTyConName :: Name
fromStringName = methName dATA_STRING FSLIT("fromString") fromStringClassOpKey
otherwiseIdName = varQual gHC_BASE FSLIT("otherwise") otherwiseIdKey
foldrName = varQual gHC_BASE FSLIT("foldr") foldrIdKey
breakpointAutoName= varQual gHC_BASE FSLIT("breakpointAuto") breakpointAutoIdKey
opaqueTyConName = tcQual gHC_BASE FSLIT("Opaque") opaqueTyConKey
++breakpointJumpName :: Name
breakpointJumpName
= mkInternalName
breakpointJumpIdKey
(mkOccNameFS varName FSLIT("breakpointJump"))
noSrcSpan
+breakpointCondJumpName :: Name
breakpointCondJumpName
= mkInternalName
breakpointCondJumpIdKey
(mkOccNameFS varName FSLIT("breakpointCondJump"))
noSrcSpan
+breakpointAutoJumpName :: Name
breakpointAutoJumpName
= mkInternalName
breakpointAutoJumpIdKey
noSrcSpan
-- PrelTup
+fstName, sndName :: Name
fstName = varQual dATA_TUP FSLIT("fst") fstIdKey
sndName = varQual dATA_TUP FSLIT("snd") sndIdKey
-- Module PrelNum
+numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
+ timesIntegerName, integerTyConName, smallIntegerName :: Name
numClassName = clsQual gHC_NUM FSLIT("Num") numClassKey
fromIntegerName = methName gHC_NUM FSLIT("fromInteger") fromIntegerClassOpKey
minusName = methName gHC_NUM FSLIT("-") minusClassOpKey
smallIntegerName = varQual gHC_INTEGER FSLIT("smallInteger") smallIntegerIdKey
-- PrelReal types and classes
+rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
+ integralClassName, realFracClassName, fractionalClassName,
+ fromRationalName :: Name
rationalTyConName = tcQual gHC_REAL FSLIT("Rational") rationalTyConKey
ratioTyConName = tcQual gHC_REAL FSLIT("Ratio") ratioTyConKey
ratioDataConName = conName gHC_REAL FSLIT(":%") ratioDataConKey
fromRationalName = methName gHC_REAL FSLIT("fromRational") fromRationalClassOpKey
-- PrelFloat classes
+floatingClassName, realFloatClassName :: Name
floatingClassName = clsQual gHC_FLOAT FSLIT("Floating") floatingClassKey
realFloatClassName = clsQual gHC_FLOAT FSLIT("RealFloat") realFloatClassKey
-- Class Ix
+ixClassName :: Name
ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey
-- Class Typeable
+typeableClassName, typeable1ClassName, typeable2ClassName,
+ typeable3ClassName, typeable4ClassName, typeable5ClassName,
+ typeable6ClassName, typeable7ClassName :: Name
typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey
typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey
typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey
typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey
typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey
+typeableClassNames :: [Name]
typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
, typeable3ClassName, typeable4ClassName, typeable5ClassName
, typeable6ClassName, typeable7ClassName ]
-- Class Data
+dataClassName :: Name
dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
-- Error module
+assertErrorName :: Name
assertErrorName = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey
-- Enum module (Enum, Bounded)
+enumClassName, enumFromName, enumFromToName, enumFromThenName,
+ enumFromThenToName, boundedClassName :: Name
enumClassName = clsQual gHC_ENUM FSLIT("Enum") enumClassKey
enumFromName = methName gHC_ENUM FSLIT("enumFrom") enumFromClassOpKey
enumFromToName = methName gHC_ENUM FSLIT("enumFromTo") enumFromToClassOpKey
boundedClassName = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey
-- List functions
+concatName, filterName, zipName :: Name
concatName = varQual gHC_LIST FSLIT("concat") concatIdKey
filterName = varQual gHC_LIST FSLIT("filter") filterIdKey
zipName = varQual gHC_LIST FSLIT("zip") zipIdKey
-- Class Show
+showClassName :: Name
showClassName = clsQual gHC_SHOW FSLIT("Show") showClassKey
-- Class Read
+readClassName :: Name
readClassName = clsQual gHC_READ FSLIT("Read") readClassKey
-- parallel array types and functions
+enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
+ singletonPName, replicatePName, mapPName, filterPName,
+ zipPName, crossMapPName, indexPName, toPName, bpermutePName,
+ bpermuteDftPName, indexOfPName :: Name
enumFromToPName = varQual gHC_PARR FSLIT("enumFromToP") enumFromToPIdKey
enumFromThenToPName= varQual gHC_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey
nullPName = varQual gHC_PARR FSLIT("nullP") nullPIdKey
indexOfPName = varQual gHC_PARR FSLIT("indexOfP") indexOfPIdKey
-- IOBase things
+ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
+ failIOName :: Name
ioTyConName = tcQual gHC_IO_BASE FSLIT("IO") ioTyConKey
ioDataConName = conName gHC_IO_BASE FSLIT("IO") ioDataConKey
thenIOName = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey
failIOName = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey
-- IO things
+printName :: Name
printName = varQual sYSTEM_IO FSLIT("print") printIdKey
-- Int, Word, and Addr things
+int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
int8TyConName = tcQual gHC_INT FSLIT("Int8") int8TyConKey
int16TyConName = tcQual gHC_INT FSLIT("Int16") int16TyConKey
int32TyConName = tcQual gHC_INT FSLIT("Int32") int32TyConKey
int64TyConName = tcQual gHC_INT FSLIT("Int64") int64TyConKey
-- Word module
+word8TyConName, word16TyConName, word32TyConName, word64TyConName,
+ wordTyConName, wordDataConName :: Name
word8TyConName = tcQual gHC_WORD FSLIT("Word8") word8TyConKey
word16TyConName = tcQual gHC_WORD FSLIT("Word16") word16TyConKey
word32TyConName = tcQual gHC_WORD FSLIT("Word32") word32TyConKey
wordDataConName = conName gHC_WORD FSLIT("W#") wordDataConKey
-- PrelPtr module
+ptrTyConName, funPtrTyConName :: Name
ptrTyConName = tcQual gHC_PTR FSLIT("Ptr") ptrTyConKey
funPtrTyConName = tcQual gHC_PTR FSLIT("FunPtr") funPtrTyConKey
-- Foreign objects and weak pointers
+stablePtrTyConName, newStablePtrName :: Name
stablePtrTyConName = tcQual gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey
newStablePtrName = varQual gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey
-- PrelST module
+runSTRepName :: Name
runSTRepName = varQual gHC_ST FSLIT("runSTRep") runSTRepIdKey
-- Recursive-do notation
+monadFixClassName, mfixName :: Name
monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
mfixName = methName mONAD_FIX FSLIT("mfix") mfixIdKey
-- Arrow notation
+arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
arrAName = varQual aRROW FSLIT("arr") arrAIdKey
composeAName = varQual gHC_DESUGAR FSLIT(">>>") composeAIdKey
firstAName = varQual aRROW FSLIT("first") firstAIdKey
loopAName = varQual aRROW FSLIT("loop") loopAIdKey
-- Other classes, needed for type defaulting
+monadPlusClassName, randomClassName, randomGenClassName,
+ isStringClassName :: Name
monadPlusClassName = clsQual mONAD FSLIT("MonadPlus") monadPlusClassKey
randomClassName = clsQual rANDOM FSLIT("Random") randomClassKey
randomGenClassName = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey
isStringClassName = clsQual dATA_STRING FSLIT("IsString") isStringClassKey
-- dotnet interop
+objectTyConName :: Name
objectTyConName = tcQual dOTNET FSLIT("Object") objectTyConKey
-- objectTyConName was "wTcQual", but that's gone now, and
-- I can't see why it was wired in anyway...
+unmarshalObjectName, marshalObjectName, marshalStringName,
+ unmarshalStringName, checkDotnetResName :: Name
unmarshalObjectName = varQual dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey
marshalObjectName = varQual dOTNET FSLIT("marshalObject") marshalObjectIdKey
marshalStringName = varQual dOTNET FSLIT("marshalString") marshalStringIdKey
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
\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 :: Unique
addrPrimTyConKey = mkPreludeTyConUnique 1
arrayPrimTyConKey = mkPreludeTyConUnique 3
boolTyConKey = mkPreludeTyConUnique 4
stablePtrPrimTyConKey = mkPreludeTyConUnique 35
stablePtrTyConKey = mkPreludeTyConUnique 36
+anyPrimTyConKey, anyPrimTyCon1Key :: Unique
anyPrimTyConKey = mkPreludeTyConUnique 37
anyPrimTyCon1Key = mkPreludeTyConUnique 38
+statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
+ mutVarPrimTyConKey, ioTyConKey,
+ wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
+ word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
+ liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
+ typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
+ funPtrTyConKey, tVarPrimTyConKey :: Unique
statePrimTyConKey = mkPreludeTyConUnique 50
stableNamePrimTyConKey = mkPreludeTyConUnique 51
stableNameTyConKey = mkPreludeTyConUnique 52
tVarPrimTyConKey = mkPreludeTyConUnique 76
-- Generic Type Constructors
+crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
crossTyConKey = mkPreludeTyConUnique 79
plusTyConKey = mkPreludeTyConUnique 80
genUnitTyConKey = mkPreludeTyConUnique 81
-- Parallel array type constructor
+parrTyConKey :: Unique
parrTyConKey = mkPreludeTyConUnique 82
-- dotnet interop
+objectTyConKey :: Unique
objectTyConKey = mkPreludeTyConUnique 83
+eitherTyConKey :: Unique
eitherTyConKey = mkPreludeTyConUnique 84
-- Super Kinds constructors
+tySuperKindTyConKey, coSuperKindTyConKey :: Unique
tySuperKindTyConKey = mkPreludeTyConUnique 85
coSuperKindTyConKey = mkPreludeTyConUnique 86
-- Kind constructors
+liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
+ ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
liftedTypeKindTyConKey = mkPreludeTyConUnique 87
openTypeKindTyConKey = mkPreludeTyConUnique 88
unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
argTypeKindTyConKey = mkPreludeTyConUnique 91
-- Coercion constructors
+symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
+ rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
+ :: Unique
symCoercionTyConKey = mkPreludeTyConUnique 93
transCoercionTyConKey = mkPreludeTyConUnique 94
leftCoercionTyConKey = mkPreludeTyConUnique 95
instCoercionTyConKey = mkPreludeTyConUnique 97
unsafeCoercionTyConKey = mkPreludeTyConUnique 98
+unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
+ opaqueTyConKey :: Unique
unknownTyConKey = mkPreludeTyConUnique 99
unknown1TyConKey = mkPreludeTyConUnique 130
unknown2TyConKey = mkPreludeTyConUnique 131
unknown3TyConKey = mkPreludeTyConUnique 132
opaqueTyConKey = mkPreludeTyConUnique 133
+stringTyConKey :: Unique
stringTyConKey = mkPreludeTyConUnique 134
---------------- Template Haskell -------------------
-- USES TyConUniques 100-129
-----------------------------------------------------
+unitTyConKey :: Unique
unitTyConKey = mkTupleTyConUnique Boxed 0
\end{code}
%************************************************************************
\begin{code}
+charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
+ floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
+ stableNameDataConKey, trueDataConKey, wordDataConKey,
+ ioDataConKey :: Unique
charDataConKey = mkPreludeDataConUnique 1
consDataConKey = mkPreludeDataConUnique 2
doubleDataConKey = mkPreludeDataConUnique 3
ioDataConKey = mkPreludeDataConUnique 17
-- Generic data constructors
+crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
crossDataConKey = mkPreludeDataConUnique 20
inlDataConKey = mkPreludeDataConUnique 21
inrDataConKey = mkPreludeDataConUnique 22
genUnitDataConKey = mkPreludeDataConUnique 23
-- Data constructor for parallel arrays
+parrDataConKey :: Unique
parrDataConKey = mkPreludeDataConUnique 24
+leftDataConKey, rightDataConKey :: Unique
leftDataConKey = mkPreludeDataConUnique 25
rightDataConKey = mkPreludeDataConUnique 26
\end{code}
%************************************************************************
\begin{code}
+absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
+ foldlIdKey, foldrIdKey, recSelErrorIdKey,
+ integerMinusOneIdKey, integerPlusOneIdKey,
+ integerPlusTwoIdKey, integerZeroIdKey,
+ int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
+ noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
+ runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
+ realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
+ traceIdKey,
+ unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
+ unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
absentErrorIdKey = mkPreludeMiscIdUnique 1
augmentIdKey = mkPreludeMiscIdUnique 3
appendIdKey = mkPreludeMiscIdUnique 4
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
+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, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
andIdKey = mkPreludeMiscIdUnique 57
orIdKey = mkPreludeMiscIdUnique 58
thenIOIdKey = mkPreludeMiscIdUnique 59
lazyIdKey = mkPreludeMiscIdUnique 60
assertErrorIdKey = mkPreludeMiscIdUnique 61
+breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
+ breakpointJumpIdKey, breakpointCondJumpIdKey,
+ breakpointAutoJumpIdKey :: Unique
breakpointIdKey = mkPreludeMiscIdUnique 62
breakpointCondIdKey = mkPreludeMiscIdUnique 63
breakpointAutoIdKey = mkPreludeMiscIdUnique 64
breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
+inlineIdKey :: Unique
inlineIdKey = mkPreludeMiscIdUnique 68
+mapIdKey, groupWithIdKey :: Unique
mapIdKey = mkPreludeMiscIdUnique 69
groupWithIdKey = mkPreludeMiscIdUnique 70
-- Parallel array functions
+singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
+ filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
+ enumFromToPIdKey, enumFromThenToPIdKey,
+ bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique
singletonPIdKey = mkPreludeMiscIdUnique 79
nullPIdKey = mkPreludeMiscIdUnique 80
lengthPIdKey = mkPreludeMiscIdUnique 81
indexOfPIdKey = mkPreludeMiscIdUnique 93
-- 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
+ :: Unique
fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
minusClassOpKey = mkPreludeMiscIdUnique 103
fromRationalClassOpKey = mkPreludeMiscIdUnique 104
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
---------------- Template Haskell -------------------
%************************************************************************
\begin{code}
+numericTyKeys :: [Unique]
numericTyKeys =
[ wordTyConKey
, intTyConKey
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,
(@TcDeriv@).
\begin{code}
+derivableClassKeys :: [Unique]
derivableClassKeys
= [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
boundedClassKey, showClassKey, readClassKey ]
projects / ghc-hetmet.git / blobdiff