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)
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
hsnClass2Kind :: HsName -> HsName
hsnClass2Kind = hsnClass2Dict
hsnClass2Polarity :: HsName -> HsName
hsnClass2Polarity = hsnClass2Dict
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 , 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 -> ( n, k))
mk l = [ bi i | bi <- l ]
mka a l = [ bi i a | bi <- l ]
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
, 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
}
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
, 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
}