module UHC.Light.Compiler.Base.HsName.Builtin ( hsnWild, hsnArrow, strProd, hsnProd, hsnProdArity, hsnUnknown, hsnIsArrow, hsnIsProd, hsnInt, hsnChar , hsnIsWild , hsnStrHiddenPrefix , mkHNmHidden , hsnNegate , hsnError , hsnUn, hsnIsUn, hsnUnUn , hsnEqTilde, hsnIsEqTilde , hsnCovariant, hsnContravariant, hsnInvariant , hsnIsList , hsnEnumFromThenTo, hsnEnumFromThen, hsnEnumFromTo, hsnEnumFrom , hsnBool, hsnTrue, hsnFalse, hsnDataList, hsnDataListAltCons, hsnDataListAltNil, hsnClassEqFldEq, hsnPrelConcatMap , charKindStar, hsnKindStar , mkHNmSpecial , hsnORow, hsnCRow, hsnORec, hsnCRec, hsnOSum, hsnCSum , hsnRow, hsnRec, hsnSum, hsnRowEmpty, hsnIsRec, hsnIsSum, hsnIsRow , positionalFldNames , hsnKindRow , hsnMain , hsnIsConstructorName , hsnUndefined, hsnPackedString, hsnPackedStringToString, hsnPrelId, hsnPrimAddInt , EHBuiltinNames, EHBuiltinNames' (..), mkEHBuiltinNames , hsnOImpl, hsnCImpl, hsnPrArrow, hsnIsPrArrow, hsnIsUnknown , hsnMonadSeq, hsnMonadBind, hsnMonadFail, hsnClassEq , hsnClass2Dict , hsnClass2Kind , hsnClass2Polarity , hsnDynVar , hsnPolNegation , hsnFldUpd , hsnModBuiltin , hsnDataOrderingAltEQ, hsnDataOrderingAltLT, hsnDataOrderingAltGT , hsnNm2Gener, hsnNm2GenerReprSyn, hsnNm2GenerDatatype, hsnNm2GenerConstructor, hsnNm2GenerSelector, hsnNm2GenerReprTuple , builtinGenerClassNmL, builtinGenerClassArityNmL, builtinGenerTypeNmL, builtinGenerTypeArityNmL , hsnInteger , hsnInt8Unboxed, hsnInt16Unboxed, hsnInt32Unboxed, hsnInt64Unboxed, hsnWordUnboxed, hsnWord8Unboxed, hsnWord16Unboxed, hsnWord32Unboxed, hsnWord64Unboxed , hsnPackedStringToInteger, hsnPrimIntegerToInt, hsnPrimIntToInteger , hsnFromInteger , hsnFromRational , hsnMkRatio , hsnIO , hsnAddrUnboxed , hsnDataStringFromString , hsnEhcRunMain , hsnStackTracePush , hsnIsInPrelude , hsnModPrelude, hsnModIntlBase , hsnModDataString ) where import UHC.Light.Compiler.Base.HsName import Data.Maybe import UHC.Util.Utils import Data.List import Data.Char (isUpper) {-# LINE 28 "src/ehc/Base/HsName/Builtin.chs" #-} strProd :: Int -> String {-# LINE 32 "src/ehc/Base/HsName/Builtin.chs" #-} hsnArrow, hsnInt, hsnChar, hsnWild :: HsName hsnProd :: Int -> HsName hsnProdArity :: HsName -> Int {-# LINE 38 "src/ehc/Base/HsName/Builtin.chs" #-} hsnArrow = hsnFromString "->" hsnInt = hsnFromString "Int" hsnChar = hsnFromString "Char" hsnWild = hsnFromString "_" strProd i = ',' : show i hsnProd = hsnFromString . strProd hsnIsArrow, hsnIsProd :: HsName -> Bool hsnIsArrow hsn = hsn == hsnArrow hsnIsProd n | isJust ms = case m of (',':_) -> True _ -> False where ms@(~(Just m)) = hsnMbBaseString n hsnIsProd _ = False hsnProdArity n | isJust ms = case m of (_:ar) -> read ar _ -> 0 where ms@(~(Just m)) = hsnMbBaseString n {-# LINE 63 "src/ehc/Base/HsName/Builtin.chs" #-} hsnIsWild :: HsName -> Bool hsnIsWild x = hsnQualified x == hsnWild {-# LINE 72 "src/ehc/Base/HsName/Builtin.chs" #-} hsnStrHiddenPrefix = "_'" {-# LINE 76 "src/ehc/Base/HsName/Builtin.chs" #-} hsnStrSpecialPrefix = "_" {-# LINE 80 "src/ehc/Base/HsName/Builtin.chs" #-} mkHNmHidden :: HSNM x => x -> HsName mkHNmHidden = mkHNmPrefix hsnStrHiddenPrefix {-# LINE 85 "src/ehc/Base/HsName/Builtin.chs" #-} mkHNmSpecial :: HSNM x => x -> HsName mkHNmSpecial = mkHNmPrefix hsnStrSpecialPrefix {-# LINE 95 "src/ehc/Base/HsName/Builtin.chs" #-} strUn = hsnStrHiddenPrefix ++ "un" {-# LINE 99 "src/ehc/Base/HsName/Builtin.chs" #-} strFldUpd = hsnStrHiddenPrefix ++ "upd_" {-# LINE 108 "src/ehc/Base/HsName/Builtin.chs" #-} hsnUn :: HsName -> HsName hsnUn nm = strUn `hsnPrefix` nm {-# LINE 113 "src/ehc/Base/HsName/Builtin.chs" #-} hsnIsUn :: HsName -> Bool hsnIsUn = maybe False (isPrefixOf strUn) . hsnMbBaseString {-# LINE 126 "src/ehc/Base/HsName/Builtin.chs" #-} hsnUnUn :: HsName -> HsName hsnUnUn n = maybe n (\(s,mk) -> mk $ drop (length strUn) s) $ hsnBaseUnpack n {-# LINE 144 "src/ehc/Base/HsName/Builtin.chs" #-} hsnFldUpd :: HsName -> HsName hsnFldUpd nm = strFldUpd `hsnPrefix` nm {-# LINE 149 "src/ehc/Base/HsName/Builtin.chs" #-} hsnIsList hsn = hsn == hsnDataList {-# LINE 153 "src/ehc/Base/HsName/Builtin.chs" #-} hsnORow = hsnFromString "{|" hsnCRow = hsnFromString "|}" hsnOSum = hsnFromString "{<" hsnCSum = hsnFromString ">}" hsnORec = hsnFromString "(" hsnCRec = hsnFromString ")" {-# LINE 162 "src/ehc/Base/HsName/Builtin.chs" #-} hsnRow = hsnFromString (hsnStrSpecialPrefix ++ "Row") hsnRec = hsnFromString (hsnStrSpecialPrefix ++ "Rec") hsnSum = hsnFromString (hsnStrSpecialPrefix ++ "Var") hsnRowEmpty = hsnFromString (show hsnORow ++ show hsnCRow) hsnIsRec, hsnIsSum, hsnIsRow :: HsName -> Bool hsnIsRec hsn = hsn == hsnRec hsnIsSum hsn = hsn == hsnSum hsnIsRow hsn = hsn == hsnRow {-# LINE 174 "src/ehc/Base/HsName/Builtin.chs" #-} positionalFldNames :: [HsName] positionalFldNames = map mkHNmPos [1..] {-# LINE 179 "src/ehc/Base/HsName/Builtin.chs" #-} hsnMain = hsnFromString "main" {-# LINE 183 "src/ehc/Base/HsName/Builtin.chs" #-} constructorInitial :: Char -> Bool constructorInitial ':' = True constructorInitial '[' = True constructorInitial ',' = True constructorInitial '(' = True constructorInitial c = isUpper c hsnIsConstructorName :: HsName -> Bool hsnIsConstructorName n | isJust ms = constructorInitial x | hsnIsPos n = False where ms@(~(Just (~(x:xs)))) = hsnMbBaseString n {-# LINE 196 "src/ehc/Base/HsName/Builtin.chs" #-} hsnIsConstructorName n = hsnIsConstructorName (snd $ hsnInitLast n) {-# LINE 200 "src/ehc/Base/HsName/Builtin.chs" #-} hsnOImpl = hsnFromString "{!" hsnCImpl = hsnFromString "!}" hsnPrArrow = hsnFromString "=>" hsnIsPrArrow :: HsName -> Bool hsnIsPrArrow hsn = hsn == hsnPrArrow hsnIsUnknown = (==hsnUnknown) {-# LINE 210 "src/ehc/Base/HsName/Builtin.chs" #-} hsnDynVar = hsnFromString "?" {-# LINE 214 "src/ehc/Base/HsName/Builtin.chs" #-} hsnEqTilde = hsnFromString "~" hsnIsEqTilde = (==hsnEqTilde) {-# LINE 220 "src/ehc/Base/HsName/Builtin.chs" #-} hsnCovariant, hsnContravariant, hsnInvariant :: HsName hsnCovariant = mkHNm "+Covariant" hsnContravariant = mkHNm "-Contravariant" hsnInvariant = mkHNm "*Invariant" {-# LINE 227 "src/ehc/Base/HsName/Builtin.chs" #-} hsnPolNegation :: HsName hsnPolNegation = mkHNm "^Negate" {-# LINE 241 "src/ehc/Base/HsName/Builtin.chs" #-} hsnInteger = hsnFromString "Integer" {-# LINE 249 "src/ehc/Base/HsName/Builtin.chs" #-} charKindStar = '*' hsnKindStar = hsnFromString [charKindStar] {-# LINE 254 "src/ehc/Base/HsName/Builtin.chs" #-} hsnKindRow = hsnRow {-# LINE 273 "src/ehc/Base/HsName/Builtin.chs" #-} hsnInt8Unboxed = hsnFromString "Int8#" hsnInt16Unboxed = hsnFromString "Int16#" hsnInt32Unboxed = hsnFromString "Int32#" hsnInt64Unboxed = hsnFromString "Int64#" hsnWordUnboxed = hsnFromString "Word#" hsnWord8Unboxed = hsnFromString "Word8#" hsnWord16Unboxed = hsnFromString "Word16#" hsnWord32Unboxed = hsnFromString "Word32#" hsnWord64Unboxed = hsnFromString "Word64#" {-# LINE 285 "src/ehc/Base/HsName/Builtin.chs" #-} hsnAddrUnboxed = hsnFromString "Addr#" {-# LINE 306 "src/ehc/Base/HsName/Builtin.chs" #-} mkRV' :: HsName -> HsName -> HsName mkRV' m = hsnSetQual m mkRV :: HsName -> String -> HsName mkRV m = mkRV' m . hsnFromString mkGenerRV :: String -> HsName mkGenerRV = mkRV hsnModIntlBase {-# LINE 317 "src/ehc/Base/HsName/Builtin.chs" #-} mkGenerRVN' :: Int -> String -> String -> HsName mkGenerRVN' n s suff = mkGenerRV (s ++ show n ++ suff) mkGenerRVN :: Int -> String -> HsName mkGenerRVN n s = mkGenerRVN' n s "" mkGenerRVN2 :: Int -> String -> HsName mkGenerRVN2 n s = mkGenerRVN' n s "_" {-# LINE 332 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnNegate] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlNum) [ "negate" ] {-# LINE 343 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnError] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlBase) [ "error" ] {-# LINE 360 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnEnumFromThenTo,hsnEnumFromThen,hsnEnumFromTo,hsnEnumFrom] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlEnum) [ "enumFromThenTo", "enumFromThen", "enumFromTo", "enumFrom" ] {-# LINE 371 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnClassIx, hsnClassIxFldRange, hsnClassIxFldIndex, hsnClassIxFldInRange] = map (mkRV hsnModIntlIx) -- (mkRV hsnModIntlEnum) [ "Ix", "range", "index", "inRange" ] {-# LINE 378 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnDataList,hsnDataListAltCons,hsnDataListAltNil,hsnPrelConcatMap , hsnBool,hsnTrue,hsnFalse , hsnDataOrdering, hsnDataOrderingAltEQ, hsnDataOrderingAltLT, hsnDataOrderingAltGT , hsnPrelString , hsnClassEqFldEq , hsnMap , hsnClassBounded, hsnClassBoundedFldMinBound, hsnClassBoundedFldMaxBound , hsnClassEnum, hsnClassEnumFldFromEnum, hsnClassEnumFldToEnum, hsnClassEnumFldSucc, hsnClassEnumFldPred ] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlBase) [ "[]", ":", "[]", "concatMap" , "Bool", "True", "False" , "Ordering", "EQ", "LT", "GT" , "String" , "==" , "map" , "Bounded", "minBound", "maxBound" , "Enum", "fromEnum", "toEnum", "succ", "pred" ] {-# LINE 418 "src/ehc/Base/HsName/Builtin.chs" #-} [ hsnUndefined , hsnPackedString , hsnPackedStringToString , hsnPrelId , hsnPrimAddInt , hsnPrimGtInt , hsnPrimLtInt , hsnPackedStringToInteger , hsnPrimIntegerToInt , hsnPrimIntToInteger , hsnPrimEqChar ] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlBase) [ "undefined" , "PackedString" , "packedStringToString" , "id" , "primAddInt" , "primGtInt" , "primLtInt" , "packedStringToInteger" , "primIntegerToInt" , "primIntToInteger" , "primEqChar" ] {-# LINE 469 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnMonadSeq,hsnMonadBind,hsnMonadFail , hsnClassEq , hsnBoolAnd , hsnBoolOr , hsnClassOrd, hsnClassOrdFldCompare , hsnPrelConcat2, hsnPrelConcat , hsnPrelCompose ] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlBase) [ ">>", ">>=", "fail" , "Eq" , "&&" , "||" , "Ord", "compare" , "++", "concat" , "." ] {-# LINE 502 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnFunPtr] = map (mkRV hsnModIntlPtr) [ "FunPtr" ] {-# LINE 514 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnAddr] = map (mkRV hsnModIntlTypes) [ "Addr" ] {-# LINE 526 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnClassShow , hsnClassShowFldShow, hsnClassShowFldShowsPrec , hsnPrelShowString, hsnPrelShowParen ] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlShow) [ "Show" , "show", "showsPrec" , "showString", "showParen" ] {-# LINE 543 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnClassRead , hsnClassReadFldRead, hsnClassReadFldReadsPrec , hsnPrelLex, hsnPrelReadParen ] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlRead) [ "Read" , "read", "readsPrec" , "lex", "readParen" ] {-# LINE 564 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnFromInteger] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlNum) [ "fromInteger" ] {-# LINE 575 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnFloat,hsnDouble ] = map (mkRV hsnModIntlBase) [ "Float", "Double" ] {-# LINE 588 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnWord,hsnWord8,hsnWord16,hsnWord32,hsnWord64 ] = map (mkRV hsnModIntlTypes) [ "Word", "Word8", "Word16", "Word32", "Word64" ] {-# LINE 601 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnInt8, hsnInt16, hsnInt32, hsnInt64 ] = map (mkRV hsnModIntlTypes) [ "Int8" , "Int16" , "Int32" , "Int64" ] {-# LINE 614 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnFromRational] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlFractional) [ "fromRational" ] {-# LINE 625 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnMkRatio] = map (mkRV hsnModIntlBase) -- (mkRV hsnModIntlRatio) [ ":%" ] {-# LINE 640 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnIO,hsnHandle,hsnByteArray,hsnRealWorld] = map (mkRV hsnModIntlBase) [ "IO", "Handle", "ByteArray", "RealWorld" ] {-# LINE 655 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnDataStringFromString] = map (mkRV hsnModDataString) [ "fromString" ] {-# LINE 666 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnEhcRunMain] = map (mkRV hsnModIntlRun) [ "ehcRunMain" ] {-# LINE 677 "src/ehc/Base/HsName/Builtin.chs" #-} [hsnStackTracePush] = map (mkRV hsnModIntlBase) [ "pushExplicitStackTrace" ] {-# LINE 688 "src/ehc/Base/HsName/Builtin.chs" #-} hsnModBuiltin = mkHNm "#Builtin" {-# LINE 696 "src/ehc/Base/HsName/Builtin.chs" #-} hsnUHC = hsnFromString "UHC" {-# LINE 700 "src/ehc/Base/HsName/Builtin.chs" #-} hsnData = hsnFromString "Data" {-# LINE 704 "src/ehc/Base/HsName/Builtin.chs" #-} hsnIsInPrelude :: HsName -> Bool hsnIsInPrelude n = case hsnInitLast n of ((m:_),_) -> m == hsnUHC _ -> False {-# LINE 712 "src/ehc/Base/HsName/Builtin.chs" #-} hsnModIntlGenericsTuple = hsnPrefixQual hsnUHC (mkHNm "Generics.Tuple") {-# LINE 716 "src/ehc/Base/HsName/Builtin.chs" #-} -- hsnModIntlRatio = hsnPrefixQual hsnUHC (hsnFromString "Ratio") -- hsnModIntlReal = hsnPrefixQual hsnUHC (hsnFromString "Real") -- hsnModIntlFractional = hsnPrefixQual hsnUHC (hsnFromString "Fractional") hsnModIntlBase = hsnPrefixQual hsnUHC (hsnFromString "Base") hsnModIntlEnum = hsnPrefixQual hsnUHC (hsnFromString "Enum") hsnModIntlIx = hsnPrefixQual hsnUHC (hsnFromString "Ix") hsnModIntlNum = hsnPrefixQual hsnUHC (hsnFromString "Num") hsnModIntlGenerics = hsnPrefixQual hsnUHC (hsnFromString "Generics") hsnModIntlRead = hsnPrefixQual hsnUHC (hsnFromString "Read") hsnModIntlShow = hsnPrefixQual hsnUHC (hsnFromString "Show") hsnModPrelude = hsnFromString "Prelude" {-# LINE 730 "src/ehc/Base/HsName/Builtin.chs" #-} hsnModDataString = hsnPrefixQual hsnData (hsnFromString "String") {-# LINE 734 "src/ehc/Base/HsName/Builtin.chs" #-} hsnModIntlTypes = hsnPrefixQual hsnUHC (hsnFromString "Types") hsnModIntlPtr = hsnPrefixQual hsnUHC (hsnFromString "Ptr") hsnModIntlRun = hsnPrefixQual hsnUHC (hsnFromString "Run") hsnModIntlIOBase = hsnPrefixQual hsnUHC (hsnFromString "IOBase") hsnModIntlStackTrace = hsnPrefixQual hsnUHC (hsnFromString "StackTrace") {-# LINE 746 "src/ehc/Base/HsName/Builtin.chs" #-} -- Dict datatype name for class name, only used when `not ehcCfgClassViaRec' hsnClass2Dict :: HsName -> HsName hsnClass2Dict = mkHNmHidden -- . hsnPrefix "Dict_" {-# LINE 752 "src/ehc/Base/HsName/Builtin.chs" #-} hsnClass2Kind :: HsName -> HsName hsnClass2Kind = hsnClass2Dict -- mkHNmHidden . hsnPrefix "ClassKind_" {-# LINE 757 "src/ehc/Base/HsName/Builtin.chs" #-} hsnClass2Polarity :: HsName -> HsName hsnClass2Polarity = hsnClass2Dict -- mkHNmHidden . hsnPrefix "ClassPolarity_" {-# LINE 766 "src/ehc/Base/HsName/Builtin.chs" #-} -- | a hidden name corresponding to visible names hsnNm2Gener :: HsName -> HsName hsnNm2Gener = mkHNmHidden -- . hsnPrefix "Dict-" -- | a hidden, but programmer accessible, name for representation type synonym, for datatypes hsnNm2GenerReprSyn :: Int -> HsName -> HsName hsnNm2GenerReprSyn i = mkHNmSpecial . hsnPrefix ("Rep" ++ show i) -- | a hidden, but programmer accessible, name for representation type synonym, for tuples hsnNm2GenerReprTuple :: Int -> Int -> HsName hsnNm2GenerReprTuple arity i = hsnNm2GenerReprSyn i (mkHNm $ "Tuple" ++ show arity) -- | a hidden name for representation datatype for a datatype hsnNm2GenerDatatype :: HsName -> HsName hsnNm2GenerDatatype = hsnNm2Gener . hsnPrefix ("D_") -- | a hidden name for representation datatype for a datatype constructor hsnNm2GenerConstructor :: HsName -> HsName hsnNm2GenerConstructor = hsnNm2Gener . hsnPrefix ("C_") -- | a hidden name for representation datatype for a datatype field selector hsnNm2GenerSelector :: HsName -> HsName hsnNm2GenerSelector = hsnNm2Gener . hsnPrefix ("S_") {-# LINE 796 "src/ehc/Base/HsName/Builtin.chs" #-} builtinGenerClassNmL , builtinGenerTypeNmL :: [(HsName,IdOccKind)] builtinGenerClassArityNmL, builtinGenerTypeArityNmL :: Int -> [(HsName,IdOccKind)] ( builtinGenerClassNmL , builtinGenerClassArityNmL , builtinGenerTypeNmL , builtinGenerTypeArityNmL ) = ( mk [ ehbnGenerClassConstructor , ehbnGenerClassDatatype , ehbnGenerClassSelector ] , \arity -> mka arity [ ehbnGenerClassRepresentableN ] , mk $ [ ehbnGenerDataVoid1 , ehbnGenerDataUnit1 , ehbnGenerDataKonst1 , ehbnGenerDataMeta1 , ehbnGenerDataFixity , ehbnGenerDataAssociativity , ehbnGenerDataSum , ehbnGenerDataProd , ehbnGenerDataMetaB , ehbnGenerDataMetaR , ehbnGenerDataMetaP , ehbnGenerDataMetaD , ehbnGenerDataMetaC , ehbnGenerDataMetaS , ehbnGenerDataMetaS1 ] , \arity -> ( mka arity [ ehbnGenerDataMetaDN , ehbnGenerDataMetaCN ] ) ++ mk (case arity of 0 -> [ ehbnGenerDataPar0 , ehbnGenerDataRec0 ] 1 -> [ ehbnGenerDataPar1 , ehbnGenerDataRec1 , ehbnGenerDataComp1 ] _ -> [] ) ) where i = mkEHBuiltinNames (\k n -> ({- hsnQualified -} n, k)) mk l = [ bi i | bi <- l ] mka a l = [ bi i a | bi <- l ] {-# LINE 856 "src/ehc/Base/HsName/Builtin.chs" #-} type EHBuiltinNames = EHBuiltinNames' HsName data EHBuiltinNames' nm = EHBuiltinNames { ehbnId :: nm , ehbnUndefined :: nm , ehbnError :: nm , ehbnPackedString :: nm , ehbnPackedStringToString :: nm , ehbnPrimAddInt :: nm , ehbnPrimGtInt :: nm , ehbnBoolTrue :: nm , ehbnBoolFalse :: nm , ehbnDataListAltNil :: nm , ehbnDataListAltCons :: nm , ehbnDataOrderingAltLT :: nm , ehbnDataOrderingAltEQ :: nm , ehbnDataOrderingAltGT :: nm , ehbnDataList :: nm , ehbnDataBool :: nm , ehbnPrelString :: nm , ehbnFunPtr :: nm , ehbnMap :: nm , ehbnBoolAnd :: nm , ehbnBoolOr :: nm , ehbnClassEq :: nm , ehbnClassEqFldEq :: nm , ehbnClassOrd :: nm , ehbnClassOrdFldCompare :: nm , ehbnDataOrdering :: nm , ehbnClassShow :: nm , ehbnClassShowFldShow :: nm , ehbnClassShowFldShowsPrec :: nm , ehbnPrelShowString :: nm , ehbnPrelShowParen :: nm , ehbnPrelConcat :: nm , ehbnPrelConcat2 :: nm , ehbnPrelConcatMap :: nm , ehbnPrelCompose :: nm , ehbnClassEnum :: nm , ehbnClassEnumFldFromEnum :: nm , ehbnClassEnumFldToEnum :: nm , ehbnClassEnumFldSucc :: nm , ehbnClassEnumFldPred :: nm , ehbnClassEnumFldEnumFrom :: nm , ehbnClassEnumFldEnumFromTo :: nm , ehbnClassEnumFldEnumFromThen :: nm , ehbnClassEnumFldEnumFromThenTo :: nm , ehbnClassBounded :: nm , ehbnClassBoundedFldMinBound :: nm , ehbnClassBoundedFldMaxBound :: nm , ehbnPrimLtInt :: nm -- for generic deriving , ehbnGenerClassGeneric :: nm , ehbnGenerClassRepresentableN :: Int -> nm , ehbnGenerClassRepresentableNFldFrom :: Int -> nm , ehbnGenerClassRepresentableNFldTo :: Int -> nm , ehbnGenerClassDatatype :: nm , ehbnGenerClassDatatypeFldName :: nm , ehbnGenerClassDatatypeFldModule :: nm , ehbnGenerClassSelector :: nm , ehbnGenerClassSelectorFldName :: nm , ehbnGenerDataNoSelector :: nm , ehbnGenerClassConstructor :: nm , ehbnGenerClassConstructorFldName :: nm , ehbnGenerClassConstructorFldFixity :: nm , ehbnGenerClassConstructorFldIsRec :: nm , ehbnGenerDataVoid1 :: nm , ehbnGenerDataUnit1 :: nm , ehbnGenerDataUnit1AltU1 :: nm , ehbnGenerDataKonst1 :: nm , ehbnGenerDataKonst1AltK1 :: nm , ehbnGenerDataMeta1 :: nm , ehbnGenerDataMeta1AltM1 :: nm , ehbnGenerDataFixity :: nm , ehbnGenerDataFixityAltPrefix :: nm , ehbnGenerDataFixityAltInfix :: nm , ehbnGenerDataAssociativity :: nm , ehbnGenerDataAssociativityAltLeft :: nm , ehbnGenerDataAssociativityAltRight :: nm , ehbnGenerDataAssociativityAltNot :: nm , ehbnGenerDataSum :: nm , ehbnGenerDataSumAltLeft :: nm , ehbnGenerDataSumAltRight :: nm , ehbnGenerDataProd :: nm , ehbnGenerDataProdAltProd :: nm , ehbnGenerDataPar0 :: nm , ehbnGenerDataPar1 :: nm , ehbnGenerDataPar1AltPar1 :: nm , ehbnGenerDataRec0 :: nm , ehbnGenerDataRec1 :: nm , ehbnGenerDataRec1AltRec1 :: nm , ehbnGenerDataComp1 :: nm , ehbnGenerDataComp1AltComp1 :: nm , ehbnGenerDataMetaB :: nm , ehbnGenerDataMetaR :: nm , ehbnGenerDataMetaP :: nm , ehbnGenerDataMetaD :: nm , ehbnGenerDataMetaC :: nm , ehbnGenerDataMetaS :: nm , ehbnGenerDataMetaDN :: Int -> nm , ehbnGenerDataMetaCN :: Int -> nm , ehbnGenerDataMetaS1 :: nm , ehbnGenerTupleRepresentableN :: Int -> Int -> nm , ehbnInt8 :: nm , ehbnInt16 :: nm , ehbnInt32 :: nm , ehbnInt64 :: nm , ehbnWord :: nm , ehbnWord8 :: nm , ehbnWord16 :: nm , ehbnWord32 :: nm , ehbnWord64 :: nm , ehbnFloat :: nm , ehbnDouble :: nm , ehbnPackedStringToInteger :: nm , ehbnPrimIntToInteger :: nm , ehbnFromInteger :: nm , ehbnIO :: nm , ehbnHandle :: nm , ehbnByteArray :: nm , ehbnRealWorld :: nm , ehbnClassIx :: nm , ehbnClassIxFldRange :: nm , ehbnClassIxFldIndex :: nm , ehbnClassIxFldInRange :: nm , ehbnClassRead :: nm , ehbnClassReadFldRead :: nm , ehbnClassReadFldReadsPrec :: nm , ehbnPrelLex :: nm , ehbnPrelReadParen :: nm , ehbnPrimEqChar :: nm , ehbnAddr :: nm -- , ehbnStackTracePush :: nm } mkEHBuiltinNames :: (IdOccKind -> HsName -> nm) -> EHBuiltinNames' nm mkEHBuiltinNames f = EHBuiltinNames { ehbnId = f IdOcc_Val hsnPrelId , ehbnUndefined = f IdOcc_Val hsnUndefined , ehbnError = f IdOcc_Val hsnError , ehbnPackedString = f IdOcc_Type hsnPackedString , ehbnPackedStringToString = f IdOcc_Val hsnPackedStringToString , ehbnPrimAddInt = f IdOcc_Val hsnPrimAddInt , ehbnPrimGtInt = f IdOcc_Val hsnPrimGtInt , ehbnBoolTrue = f IdOcc_Val hsnTrue , ehbnBoolFalse = f IdOcc_Val hsnFalse , ehbnDataListAltNil = f IdOcc_Val hsnDataListAltNil , ehbnDataListAltCons = f IdOcc_Val hsnDataListAltCons , ehbnDataOrderingAltLT = f IdOcc_Val hsnDataOrderingAltLT , ehbnDataOrderingAltEQ = f IdOcc_Val hsnDataOrderingAltEQ , ehbnDataOrderingAltGT = f IdOcc_Val hsnDataOrderingAltGT , ehbnDataBool = f IdOcc_Type hsnBool , ehbnDataList = f IdOcc_Type hsnDataList , ehbnPrelString = f IdOcc_Type hsnPrelString , ehbnFunPtr = f IdOcc_Type hsnFunPtr , ehbnMap = f IdOcc_Type hsnMap , ehbnBoolAnd = f IdOcc_Val hsnBoolAnd , ehbnBoolOr = f IdOcc_Val hsnBoolOr , ehbnClassEq = f IdOcc_Class hsnClassEq , ehbnClassEqFldEq = f IdOcc_Val hsnClassEqFldEq , ehbnClassOrd = f IdOcc_Class hsnClassOrd , ehbnClassOrdFldCompare = f IdOcc_Val hsnClassOrdFldCompare , ehbnDataOrdering = f IdOcc_Type hsnDataOrdering , ehbnClassShow = f IdOcc_Class hsnClassShow , ehbnClassShowFldShow = f IdOcc_Val hsnClassShowFldShow , ehbnClassShowFldShowsPrec = f IdOcc_Val hsnClassShowFldShowsPrec , ehbnPrelShowString = f IdOcc_Val hsnPrelShowString , ehbnPrelShowParen = f IdOcc_Val hsnPrelShowParen , ehbnPrelConcat = f IdOcc_Val hsnPrelConcat , ehbnPrelConcat2 = f IdOcc_Val hsnPrelConcat2 , ehbnPrelConcatMap = f IdOcc_Val hsnPrelConcatMap , ehbnPrelCompose = f IdOcc_Val hsnPrelCompose , ehbnClassEnum = f IdOcc_Class hsnClassEnum , ehbnClassEnumFldFromEnum = f IdOcc_Val hsnClassEnumFldFromEnum , ehbnClassEnumFldToEnum = f IdOcc_Val hsnClassEnumFldToEnum , ehbnClassEnumFldSucc = f IdOcc_Val hsnClassEnumFldSucc , ehbnClassEnumFldPred = f IdOcc_Val hsnClassEnumFldPred , ehbnClassEnumFldEnumFrom = f IdOcc_Val hsnEnumFrom , ehbnClassEnumFldEnumFromTo = f IdOcc_Val hsnEnumFromTo , ehbnClassEnumFldEnumFromThen = f IdOcc_Val hsnEnumFromThen , ehbnClassEnumFldEnumFromThenTo = f IdOcc_Val hsnEnumFromThenTo , ehbnClassBounded = f IdOcc_Class hsnClassBounded , ehbnClassBoundedFldMinBound = f IdOcc_Val hsnClassBoundedFldMinBound , ehbnClassBoundedFldMaxBound = f IdOcc_Val hsnClassBoundedFldMaxBound , ehbnPrimLtInt = f IdOcc_Val hsnPrimLtInt -- for generic deriving , ehbnGenerClassGeneric = f IdOcc_Class (mkGenerRV "Generic" ) , ehbnGenerClassRepresentableN = \n -> f IdOcc_Class (mkGenerRVN n "Representable" ) , ehbnGenerClassRepresentableNFldFrom = \n -> f IdOcc_Val (mkGenerRVN n "from" ) , ehbnGenerClassRepresentableNFldTo = \n -> f IdOcc_Val (mkGenerRVN n "to" ) , ehbnGenerClassDatatype = f IdOcc_Class (mkGenerRV "Datatype" ) , ehbnGenerClassDatatypeFldName = f IdOcc_Val (mkGenerRV "datatypeName" ) , ehbnGenerClassDatatypeFldModule = f IdOcc_Val (mkGenerRV "moduleName" ) , ehbnGenerClassSelector = f IdOcc_Class (mkGenerRV "Selector" ) , ehbnGenerClassSelectorFldName = f IdOcc_Val (mkGenerRV "selName" ) , ehbnGenerDataNoSelector = f IdOcc_Type (mkGenerRV "NoSelector" ) , ehbnGenerClassConstructor = f IdOcc_Class (mkGenerRV "Constructor" ) , ehbnGenerClassConstructorFldName = f IdOcc_Val (mkGenerRV "conName" ) , ehbnGenerClassConstructorFldFixity = f IdOcc_Val (mkGenerRV "conFixity" ) , ehbnGenerClassConstructorFldIsRec = f IdOcc_Val (mkGenerRV "conIsRecord" ) , ehbnGenerDataVoid1 = f IdOcc_Type (mkGenerRV "V1" ) , ehbnGenerDataUnit1 = f IdOcc_Type (mkGenerRV "U1" ) , ehbnGenerDataUnit1AltU1 = f IdOcc_Val (mkGenerRV "U1" ) , ehbnGenerDataKonst1 = f IdOcc_Type (mkGenerRV "K1" ) , ehbnGenerDataKonst1AltK1 = f IdOcc_Val (mkGenerRV "K1" ) , ehbnGenerDataMeta1 = f IdOcc_Type (mkGenerRV "M1" ) , ehbnGenerDataMeta1AltM1 = f IdOcc_Val (mkGenerRV "M1" ) , ehbnGenerDataFixity = f IdOcc_Type (mkGenerRV "Fixity" ) , ehbnGenerDataFixityAltPrefix = f IdOcc_Val (mkGenerRV "Prefix" ) , ehbnGenerDataFixityAltInfix = f IdOcc_Val (mkGenerRV "Infix" ) , ehbnGenerDataAssociativity = f IdOcc_Type (mkGenerRV "Associativity" ) , ehbnGenerDataAssociativityAltLeft = f IdOcc_Val (mkGenerRV "LeftAssociative" ) , ehbnGenerDataAssociativityAltRight = f IdOcc_Val (mkGenerRV "RightAssociative" ) , ehbnGenerDataAssociativityAltNot = f IdOcc_Val (mkGenerRV "NotAssociative" ) , ehbnGenerDataSum = f IdOcc_Type (mkGenerRV ":+:" ) , ehbnGenerDataSumAltLeft = f IdOcc_Val (mkGenerRV "L1" ) , ehbnGenerDataSumAltRight = f IdOcc_Val (mkGenerRV "R1" ) , ehbnGenerDataProd = f IdOcc_Type (mkGenerRV ":*:" ) , ehbnGenerDataProdAltProd = f IdOcc_Val (mkGenerRV ":*:" ) , ehbnGenerDataPar0 = f IdOcc_Type (mkGenerRV "Par0" ) , ehbnGenerDataPar1 = f IdOcc_Type (mkGenerRV "Par1" ) , ehbnGenerDataPar1AltPar1 = f IdOcc_Val (mkGenerRV "Par1" ) , ehbnGenerDataRec0 = f IdOcc_Type (mkGenerRV "Rec0" ) , ehbnGenerDataRec1 = f IdOcc_Type (mkGenerRV "Rec1" ) , ehbnGenerDataRec1AltRec1 = f IdOcc_Val (mkGenerRV "Rec1" ) , ehbnGenerDataComp1 = f IdOcc_Type (mkGenerRV ":.:" ) , ehbnGenerDataComp1AltComp1 = f IdOcc_Val (mkGenerRV "Comp1" ) , ehbnGenerDataMetaB = f IdOcc_Type (mkGenerRV "B" ) , ehbnGenerDataMetaR = f IdOcc_Type (mkGenerRV "R" ) , ehbnGenerDataMetaP = f IdOcc_Type (mkGenerRV "P" ) , ehbnGenerDataMetaD = f IdOcc_Type (mkGenerRV "D" ) , ehbnGenerDataMetaC = f IdOcc_Type (mkGenerRV "C" ) , ehbnGenerDataMetaS = f IdOcc_Type (mkGenerRV "S" ) , ehbnGenerDataMetaDN = \n -> f IdOcc_Type (mkGenerRVN n "D" ) , ehbnGenerDataMetaCN = \n -> f IdOcc_Type (mkGenerRVN n "C" ) , ehbnGenerDataMetaS1 = f IdOcc_Type (mkGenerRV "S1" ) , ehbnGenerTupleRepresentableN = \n a -> f IdOcc_Type (mkRV' hsnModIntlGenericsTuple $ hsnNm2GenerReprTuple a n) , ehbnInt8 = f IdOcc_Type hsnInt8 , ehbnInt16 = f IdOcc_Type hsnInt16 , ehbnInt32 = f IdOcc_Type hsnInt32 , ehbnInt64 = f IdOcc_Type hsnInt64 , ehbnWord = f IdOcc_Type hsnWord , ehbnWord8 = f IdOcc_Type hsnWord8 , ehbnWord16 = f IdOcc_Type hsnWord16 , ehbnWord32 = f IdOcc_Type hsnWord32 , ehbnWord64 = f IdOcc_Type hsnWord64 , ehbnFloat = f IdOcc_Type hsnFloat , ehbnDouble = f IdOcc_Type hsnDouble , ehbnPackedStringToInteger = f IdOcc_Val hsnPackedStringToInteger , ehbnPrimIntToInteger = f IdOcc_Val hsnPrimIntToInteger , ehbnFromInteger = f IdOcc_Val hsnFromInteger , ehbnIO = f IdOcc_Type hsnIO , ehbnHandle = f IdOcc_Type hsnHandle , ehbnByteArray = f IdOcc_Type hsnByteArray , ehbnRealWorld = f IdOcc_Type hsnRealWorld , ehbnClassIx = f IdOcc_Class hsnClassIx , ehbnClassIxFldRange = f IdOcc_Val hsnClassIxFldRange , ehbnClassIxFldIndex = f IdOcc_Val hsnClassIxFldIndex , ehbnClassIxFldInRange = f IdOcc_Val hsnClassIxFldInRange , ehbnClassRead = f IdOcc_Class hsnClassRead , ehbnClassReadFldRead = f IdOcc_Val hsnClassReadFldRead , ehbnClassReadFldReadsPrec = f IdOcc_Val hsnClassReadFldReadsPrec , ehbnPrelLex = f IdOcc_Val hsnPrelLex , ehbnPrelReadParen = f IdOcc_Val hsnPrelReadParen , ehbnPrimEqChar = f IdOcc_Val hsnPrimEqChar , ehbnAddr = f IdOcc_Type hsnAddr -- , ehbnStackTracePush = f IdOcc_Val hsnStackTracePush }