uhc-light-1.1.9.1: src/UHC/Light/Compiler/Base/HsName/Builtin.hs
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
}