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 (..), 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
, 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)
strProd :: Int -> String
hsnArrow, hsnInt, hsnChar, hsnWild :: HsName
hsnProd :: Int -> HsName
hsnProdArity :: HsName -> Int
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
hsnIsWild :: HsName -> Bool
hsnIsWild x = hsnQualified x == hsnWild
hsnStrHiddenPrefix = "_'"
hsnStrSpecialPrefix = "_"
mkHNmHidden :: HSNM x => x -> HsName
mkHNmHidden = mkHNmPrefix hsnStrHiddenPrefix
mkHNmSpecial :: HSNM x => x -> HsName
mkHNmSpecial = mkHNmPrefix hsnStrSpecialPrefix
strUn = hsnStrHiddenPrefix ++ "un"
strFldUpd = hsnStrHiddenPrefix ++ "upd_"
hsnUn :: HsName -> HsName
hsnUn nm = strUn `hsnPrefix` nm
hsnIsUn :: HsName -> Bool
hsnIsUn = maybe False (isPrefixOf strUn) . hsnMbBaseString
hsnUnUn :: HsName -> HsName
hsnUnUn n = maybe n (\(s,mk) -> mk $ drop (length strUn) s) $ hsnBaseUnpack n
hsnFldUpd :: HsName -> HsName
hsnFldUpd nm = strFldUpd `hsnPrefix` nm
hsnIsList hsn = hsn == hsnDataList
hsnORow = hsnFromString "{|"
hsnCRow = hsnFromString "|}"
hsnOSum = hsnFromString "{<"
hsnCSum = hsnFromString ">}"
hsnORec = hsnFromString "("
hsnCRec = hsnFromString ")"
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
positionalFldNames :: [HsName]
positionalFldNames = map mkHNmPos [1..]
hsnMain = hsnFromString "main"
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
hsnIsConstructorName n = hsnIsConstructorName (snd $ hsnInitLast n)
hsnOImpl = hsnFromString "{!"
hsnCImpl = hsnFromString "!}"
hsnPrArrow = hsnFromString "=>"
hsnIsPrArrow :: HsName -> Bool
hsnIsPrArrow hsn = hsn == hsnPrArrow
hsnIsUnknown = (==hsnUnknown)
hsnDynVar = hsnFromString "?"
hsnEqTilde = hsnFromString "~"
hsnIsEqTilde = (==hsnEqTilde)
hsnCovariant, hsnContravariant, hsnInvariant :: HsName
hsnCovariant = mkHNm "+Covariant"
hsnContravariant = mkHNm "-Contravariant"
hsnInvariant = mkHNm "*Invariant"
hsnPolNegation :: HsName
hsnPolNegation = mkHNm "^Negate"
hsnInteger = hsnFromString "Integer"
charKindStar = '*'
hsnKindStar = hsnFromString [charKindStar]
hsnKindRow = hsnRow
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#"
hsnAddrUnboxed = hsnFromString "Addr#"
mkRV' :: HsName -> HsName -> HsName
mkRV' m = hsnSetQual m
mkRV :: HsName -> String -> HsName
mkRV m = mkRV' m . hsnFromString
mkGenerRV :: String -> HsName
mkGenerRV = mkRV hsnModIntlBase
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 "_"
[hsnNegate]
= map
(mkRV hsnModIntlBase)
[ "negate" ]
[hsnError]
= map
(mkRV hsnModIntlBase)
[ "error" ]
[hsnEnumFromThenTo,hsnEnumFromThen,hsnEnumFromTo,hsnEnumFrom]
= map
(mkRV hsnModIntlBase)
[ "enumFromThenTo", "enumFromThen", "enumFromTo", "enumFrom" ]
[hsnClassIx, hsnClassIxFldRange, hsnClassIxFldIndex, hsnClassIxFldInRange]
= map
(mkRV hsnModIntlIx)
[ "Ix", "range", "index", "inRange" ]
[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)
[ "[]", ":", "[]", "concatMap"
, "Bool", "True", "False"
, "Ordering", "EQ", "LT", "GT"
, "String"
, "=="
, "map"
, "Bounded", "minBound", "maxBound"
, "Enum", "fromEnum", "toEnum", "succ", "pred"
]
[ hsnUndefined
, hsnPackedString
, hsnPackedStringToString
, hsnPrelId
, hsnPrimAddInt
, hsnPrimGtInt
, hsnPrimLtInt
, hsnPackedStringToInteger
, hsnPrimIntegerToInt
, hsnPrimIntToInteger
, hsnPrimEqChar
]
= map
(mkRV hsnModIntlBase)
[ "undefined"
, "PackedString"
, "packedStringToString"
, "id"
, "primAddInt"
, "primGtInt"
, "primLtInt"
, "packedStringToInteger"
, "primIntegerToInt"
, "primIntToInteger"
, "primEqChar"
]
[hsnMonadSeq,hsnMonadBind,hsnMonadFail
, hsnClassEq
, hsnBoolAnd
, hsnBoolOr
, hsnClassOrd, hsnClassOrdFldCompare
, hsnPrelConcat2, hsnPrelConcat
, hsnPrelCompose
]
= map
(mkRV hsnModIntlBase)
[ ">>", ">>=", "fail"
, "Eq"
, "&&"
, "||"
, "Ord", "compare"
, "++", "concat"
, "."
]
[hsnFunPtr]
= map
(mkRV hsnModIntlPtr)
[ "FunPtr"
]
[hsnAddr]
= map
(mkRV hsnModIntlTypes)
[ "Addr"
]
[hsnClassShow
, hsnClassShowFldShow, hsnClassShowFldShowsPrec
, hsnPrelShowString, hsnPrelShowParen
]
= map
(mkRV hsnModIntlBase)
[ "Show"
, "show", "showsPrec"
, "showString", "showParen"
]
[hsnClassRead
, hsnClassReadFldRead, hsnClassReadFldReadsPrec
, hsnPrelLex, hsnPrelReadParen
]
= map
(mkRV hsnModIntlBase)
[ "Read"
, "read", "readsPrec"
, "lex", "readParen"
]
[hsnFromInteger]
= map
(mkRV hsnModIntlBase)
[ "fromInteger" ]
[hsnFloat,hsnDouble
]
= map
(mkRV hsnModIntlBase)
[ "Float", "Double"
]
[hsnWord,hsnWord8,hsnWord16,hsnWord32,hsnWord64
]
= map
(mkRV hsnModIntlTypes)
[ "Word", "Word8", "Word16", "Word32", "Word64"
]
[hsnInt8, hsnInt16, hsnInt32, hsnInt64
]
= map
(mkRV hsnModIntlTypes)
[ "Int8" , "Int16" , "Int32" , "Int64"
]
[hsnFromRational]
= map
(mkRV hsnModIntlBase)
[ "fromRational" ]
[hsnMkRatio]
= map
(mkRV hsnModIntlBase)
[ ":%" ]
[hsnIO,hsnHandle,hsnByteArray,hsnRealWorld]
= map
(mkRV hsnModIntlBase)
[ "IO", "Handle", "ByteArray", "RealWorld" ]
[hsnDataStringFromString]
= map
(mkRV hsnModDataString)
[ "fromString" ]
[hsnEhcRunMain]
= map
(mkRV hsnModIntlRun)
[ "ehcRunMain" ]
[hsnStackTracePush]
= map
(mkRV hsnModIntlBase)
[ "pushExplicitStackTrace" ]
hsnModBuiltin = mkHNm "#Builtin"
hsnUHC = hsnFromString "UHC"
hsnData = hsnFromString "Data"
hsnIsInPrelude :: HsName -> Bool
hsnIsInPrelude n
= case hsnInitLast n of
((m:_),_) -> m == hsnUHC
_ -> False
hsnModIntlGenericsTuple = hsnPrefixQual hsnUHC (mkHNm "Generics.Tuple")
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"
hsnModDataString = hsnPrefixQual hsnData (hsnFromString "String")
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")
hsnClass2Dict :: HsName -> HsName
hsnClass2Dict = mkHNmHidden . hsnPrefix "Dict_"
hsnClass2Kind :: HsName -> HsName
hsnClass2Kind = mkHNmHidden . hsnPrefix "ClassKind_"
hsnClass2Polarity :: HsName -> HsName
hsnClass2Polarity = mkHNmHidden . hsnPrefix "ClassPolarity_"
hsnNm2Gener :: HsName -> HsName
hsnNm2Gener = mkHNmHidden
hsnNm2GenerReprSyn :: Int -> HsName -> HsName
hsnNm2GenerReprSyn i = mkHNmSpecial . hsnPrefix ("Rep" ++ show i)
hsnNm2GenerReprTuple :: Int -> Int -> HsName
hsnNm2GenerReprTuple arity i = hsnNm2GenerReprSyn i (mkHNm $ "Tuple" ++ show arity)
hsnNm2GenerDatatype :: HsName -> HsName
hsnNm2GenerDatatype = hsnNm2Gener . hsnPrefix ("D_")
hsnNm2GenerConstructor :: HsName -> HsName
hsnNm2GenerConstructor = hsnNm2Gener . hsnPrefix ("C_")
hsnNm2GenerSelector :: HsName -> HsName
hsnNm2GenerSelector = hsnNm2Gener . hsnPrefix ("S_")
builtinGenerClassNmL :: [HsName]
builtinGenerClassNmL
= [ bi i
| bi <- [ ehbnGenerClassConstructor
, ehbnGenerClassDatatype
, ehbnGenerClassSelector
]
]
where i = mkEHBuiltinNames (\_ n -> hsnQualified n)
data EHBuiltinNames
= EHBuiltinNames
{ ehbnId :: HsName
, ehbnUndefined :: HsName
, ehbnError :: HsName
, ehbnPackedString :: HsName
, ehbnPackedStringToString :: HsName
, ehbnPrimAddInt :: HsName
, ehbnPrimGtInt :: HsName
, ehbnBoolTrue :: HsName
, ehbnBoolFalse :: HsName
, ehbnDataListAltNil :: HsName
, ehbnDataListAltCons :: HsName
, ehbnDataOrderingAltLT :: HsName
, ehbnDataOrderingAltEQ :: HsName
, ehbnDataOrderingAltGT :: HsName
, ehbnDataList :: HsName
, ehbnDataBool :: HsName
, ehbnPrelString :: HsName
, ehbnFunPtr :: HsName
, ehbnMap :: HsName
, ehbnBoolAnd :: HsName
, ehbnBoolOr :: HsName
, ehbnClassEq :: HsName
, ehbnClassEqFldEq :: HsName
, ehbnClassOrd :: HsName
, ehbnClassOrdFldCompare :: HsName
, ehbnDataOrdering :: HsName
, ehbnClassShow :: HsName
, ehbnClassShowFldShow :: HsName
, ehbnClassShowFldShowsPrec :: HsName
, ehbnPrelShowString :: HsName
, ehbnPrelShowParen :: HsName
, ehbnPrelConcat :: HsName
, ehbnPrelConcat2 :: HsName
, ehbnPrelConcatMap :: HsName
, ehbnPrelCompose :: HsName
, ehbnClassEnum :: HsName
, ehbnClassEnumFldFromEnum :: HsName
, ehbnClassEnumFldToEnum :: HsName
, ehbnClassEnumFldSucc :: HsName
, ehbnClassEnumFldPred :: HsName
, ehbnClassEnumFldEnumFrom :: HsName
, ehbnClassEnumFldEnumFromTo :: HsName
, ehbnClassEnumFldEnumFromThen :: HsName
, ehbnClassEnumFldEnumFromThenTo :: HsName
, ehbnClassBounded :: HsName
, ehbnClassBoundedFldMinBound :: HsName
, ehbnClassBoundedFldMaxBound :: HsName
, ehbnPrimLtInt :: HsName
, ehbnGenerClassRepresentableN :: Int -> HsName
, ehbnGenerClassRepresentableNFldFrom :: Int -> HsName
, ehbnGenerClassRepresentableNFldTo :: Int -> HsName
, ehbnGenerClassDatatype :: HsName
, ehbnGenerClassDatatypeFldName :: HsName
, ehbnGenerClassDatatypeFldModule :: HsName
, ehbnGenerClassSelector :: HsName
, ehbnGenerClassSelectorFldName :: HsName
, ehbnGenerDataNoSelector :: HsName
, ehbnGenerClassConstructor :: HsName
, ehbnGenerClassConstructorFldName :: HsName
, ehbnGenerClassConstructorFldFixity :: HsName
, ehbnGenerClassConstructorFldIsRec :: HsName
, ehbnGenerDataVoid1 :: HsName
, ehbnGenerDataUnit1 :: HsName
, ehbnGenerDataUnit1AltU1 :: HsName
, ehbnGenerDataKonst1 :: HsName
, ehbnGenerDataKonst1AltK1 :: HsName
, ehbnGenerDataMeta1 :: HsName
, ehbnGenerDataMeta1AltM1 :: HsName
, ehbnGenerDataFixity :: HsName
, ehbnGenerDataFixityAltPrefix :: HsName
, ehbnGenerDataFixityAltInfix :: HsName
, ehbnGenerDataAssociativity :: HsName
, ehbnGenerDataAssociativityAltLeft :: HsName
, ehbnGenerDataAssociativityAltRight :: HsName
, ehbnGenerDataAssociativityAltNot :: HsName
, ehbnGenerDataSum :: HsName
, ehbnGenerDataSumAltLeft :: HsName
, ehbnGenerDataSumAltRight :: HsName
, ehbnGenerDataProd :: HsName
, ehbnGenerDataProdAltProd :: HsName
, ehbnGenerDataPar0 :: HsName
, ehbnGenerDataPar1 :: HsName
, ehbnGenerDataPar1AltPar1 :: HsName
, ehbnGenerDataRec0 :: HsName
, ehbnGenerDataRec1 :: HsName
, ehbnGenerDataRec1AltRec1 :: HsName
, ehbnGenerDataComp1 :: HsName
, ehbnGenerDataComp1AltComp1 :: HsName
, ehbnGenerDataMetaB :: HsName
, ehbnGenerDataMetaR :: HsName
, ehbnGenerDataMetaP :: HsName
, ehbnGenerDataMetaD :: HsName
, ehbnGenerDataMetaC :: HsName
, ehbnGenerDataMetaS :: HsName
, ehbnGenerDataMetaDN :: Int -> HsName
, ehbnGenerDataMetaCN :: Int -> HsName
, ehbnGenerDataMetaS1 :: HsName
, ehbnGenerTupleRepresentableN :: Int -> Int -> HsName
, ehbnInt8 :: HsName
, ehbnInt16 :: HsName
, ehbnInt32 :: HsName
, ehbnInt64 :: HsName
, ehbnWord :: HsName
, ehbnWord8 :: HsName
, ehbnWord16 :: HsName
, ehbnWord32 :: HsName
, ehbnWord64 :: HsName
, ehbnFloat :: HsName
, ehbnDouble :: HsName
, ehbnPackedStringToInteger :: HsName
, ehbnPrimIntToInteger :: HsName
, ehbnFromInteger :: HsName
, ehbnIO :: HsName
, ehbnHandle :: HsName
, ehbnByteArray :: HsName
, ehbnRealWorld :: HsName
, ehbnClassIx :: HsName
, ehbnClassIxFldRange :: HsName
, ehbnClassIxFldIndex :: HsName
, ehbnClassIxFldInRange :: HsName
, ehbnClassRead :: HsName
, ehbnClassReadFldRead :: HsName
, ehbnClassReadFldReadsPrec :: HsName
, ehbnPrelLex :: HsName
, ehbnPrelReadParen :: HsName
, ehbnPrimEqChar :: HsName
, ehbnAddr :: HsName
}
mkEHBuiltinNames :: (IdOccKind -> HsName -> HsName) -> EHBuiltinNames
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
, 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
}