-- UUAGC 0.9.52.1 (build/103/lib-ehc/UHC/Light/Compiler/EH.ag) module UHC.Light.Compiler.EH(AGItf (..), Decl (..), Decls, TyExpr (..), Expr (..), PatExpr (..) , ExprAnn (..), PatExprAnn (..), TyExprAnn (..) , mkLet , TyExprs, TyVar (..), TyVars, CaseAlt (..), CaseAlts, DataConstr (..), DataConstrs , mkCase, mkCase', mkIf, mkIf', mkError, mkStr, mkAlt , KiExpr (..), KiExprAnn (..) , RecExpr (..), RecPatExpr (..), RowTyExpr (..), DataField (..), DataFields, DataFieldExpr (..), DataFieldPatExpr (..) , module UHC.Light.Compiler.Base.Target , mkLet', mkIf'' , ehIsDeclVal , PrExpr (..), PrExprs , mkUnit, mkError' , FuncDep (..), FuncDeps , MbTyExpr , mkEH) where import UHC.Light.Compiler.Base.Common import UHC.Light.Compiler.Base.TermLike import UHC.Light.Compiler.Base.HsName.Builtin import UHC.Light.Compiler.HS (Range) import UHC.Light.Compiler.Ty import qualified Data.Set as Set import UHC.Light.Compiler.Base.Target (FFIWay) import UHC.Light.Compiler.Foreign deriving instance Typeable AGItf ehIsDeclVal :: Decl -> Bool ehIsDeclVal (Decl_Val _ _ _) = True ehIsDeclVal _ = False mkLet' :: Bool -> Range -> Maybe [Decl] -> Expr -> Expr mkLet' isStrict r md e = case md of Just d@(_:_) -> rngLift r Expr_Let isStrict d e _ -> e mkLet :: Range -> Maybe [Decl] -> Expr -> Expr mkLet = mkLet' False mkUnit :: Range -> Expr mkUnit r = rngLift r Expr_Rec (rngLift r RecExpr_Empty) mkError':: HsName -> Range -> String -> Expr mkError' e r m = appTopApp [rngLift r Expr_Var e,mkStr r (show r ++ ": " ++ m)] mkError :: Range -> String -> Expr mkError = mkError' hsnError mkStr :: Range -> String -> Expr mkStr r s = rngLift r Expr_SConst s mkIf'' :: [HsName] -> Range -> Expr -> Expr -> Expr -> Maybe UIDS -> UIDS -> Expr mkIf'' (bn:tn:fn:_) r c t e i failS = case c of Expr_Con _ n | n == tn -> t | n == fn -> e _ -> mkCase' r ( rngLift r Expr_TypeAs False (rngLift r TyExpr_Con bn) c ) i failS False [ mkAlt r (rngLift r PatExpr_Con tn) t , mkAlt r (rngLift r PatExpr_Con fn) e ] mkIf' :: [HsName] -> Range -> Expr -> Expr -> Expr -> Expr mkIf' ns r c t e = mkIf'' ns r c t e Nothing Set.empty mkIf :: Range -> Expr -> Expr -> Expr -> Expr mkIf = mkIf' [hsnBool,hsnTrue,hsnFalse] mkAlt :: Range -> PatExpr -> Expr -> CaseAlt mkAlt r p e = rngLift r CaseAlt_Pat p e mkCase' :: Range -> Expr -> Maybe UIDS -> UIDS -> Bool -> [CaseAlt] -> Expr mkCase' r c id failS istup as = rngLift r Expr_Case c as id failS istup mkCase :: Range -> Expr -> [(PatExpr,Expr)] -> Expr mkCase r c as = mkCase' r c Nothing Set.empty False [ mkAlt r p e | (p,e) <- as ] mkEH :: (Range -> x) -> x mkEH = rngLift emptyRange instance {-# OVERLAPPING #-} AppLike Expr () {- ExprAnn () -} where appRngApp1 r = rngLift r Expr_App appRngTop r = rngLift r Expr_AppTop appRngVar r = rngLift r Expr_Var . mkHNm appRngCon r = rngLift r Expr_Con . mkHNm appRngPar r = rngLift r Expr_Parens appProdApp l = mkEH Expr_Rec $ mkEH RecExpr_Empty `mkRow` l where mkRow = foldl (\r e -> mkEH RecExpr_Ext r Nothing e) instance {-# OVERLAPPING #-} AppLike PatExpr () {- PatExprAnn () -} where appRngApp1 r = rngLift r PatExpr_App appRngTop r = rngLift r PatExpr_AppTop appRngVar r = rngLift r PatExpr_Var . mkHNm appRngCon r = rngLift r PatExpr_Con . mkHNm appRngPar r = rngLift r PatExpr_Parens appProdApp l = mkEH PatExpr_Rec $ mkEH RecPatExpr_Empty `mkRow` l where mkRow = foldl (\r e -> mkEH RecPatExpr_Ext r Nothing e) instance {-# OVERLAPPING #-} AppLike TyExpr () {- TyExprAnn () -} where appRngApp1 r = rngLift r TyExpr_App appRngTop r = rngLift r TyExpr_AppTop appRngVar r = rngLift r TyExpr_Var . mkHNm appRngCon r = rngLift r TyExpr_Con . mkHNm appRngPar r = rngLift r TyExpr_Parens appProdApp l = mkEH TyExpr_Row $ mkEH RowTyExpr_Empty `mkRow` l where mkRow = foldl (\r e -> mkEH RowTyExpr_Ext r Nothing e) appMbAnn1 (TyExpr_Ann r a x) = Just (x, TyExpr_Ann r a) appMbAnn1 _ = Nothing appMbTop1 (TyExpr_AppTop r x) = Just (x, TyExpr_AppTop r) appMbTop1 (TyExpr_Parens r x) = Just (x, TyExpr_Parens r) appMbTop1 x = appMbAnn1 x appMbApp1 (TyExpr_App _ f a) = Just (f,a) appMbApp1 _ = Nothing appMbCon (TyExpr_Con _ n) = Just n appMbCon _ = Nothing instance {-# OVERLAPPING #-} AppLike KiExpr () {- KiExprAnn () -} where appRngApp1 r = rngLift r KiExpr_App appRngTop r = rngLift r KiExpr_AppTop appRngVar r = rngLift r KiExpr_Var . mkHNm appRngCon r = rngLift r KiExpr_Con . mkHNm appRngPar r = rngLift r KiExpr_Parens -- AGItf ------------------------------------------------------- data AGItf = AGItf_AGItf {expr_AGItf_AGItf :: !(Expr)} -- CaseAlt ----------------------------------------------------- data CaseAlt = CaseAlt_Pat {hsrange_CaseAlt_Pat :: !(Range),patExpr_CaseAlt_Pat :: !(PatExpr),expr_CaseAlt_Pat :: !(Expr)} -- CaseAlts ---------------------------------------------------- type CaseAlts = [CaseAlt] -- DataConstr -------------------------------------------------- data DataConstr = DataConstr_Constr {hsrange_DataConstr_Constr :: !(Range),conNm_DataConstr_Constr :: !(HsName),mbFixityPrio_DataConstr_Constr :: !((Maybe (Int,Fixity))),fields_DataConstr_Constr :: !(DataFields),mbGadtTyExpr_DataConstr_Constr :: !(MbTyExpr)} -- DataConstrs ------------------------------------------------- type DataConstrs = [DataConstr] -- DataField --------------------------------------------------- data DataField = DataField_Field {hsrange_DataField_Field :: !(Range),mbLabels_DataField_Field :: !((Maybe [HsName])),tyExpr_DataField_Field :: !(TyExpr)} -- DataFieldExpr ----------------------------------------------- data DataFieldExpr = DataFieldExpr_Upd {hsrange_DataFieldExpr_Upd :: !(Range),dataFieldExpr_DataFieldExpr_Upd :: !(DataFieldExpr),nm_DataFieldExpr_Upd :: !(HsName),expr_DataFieldExpr_Upd :: !(Expr)} | DataFieldExpr_Con {hsrange_DataFieldExpr_Con :: !(Range),nm_DataFieldExpr_Con :: !(HsName)} | DataFieldExpr_Expr {hsrange_DataFieldExpr_Expr :: !(Range),expr_DataFieldExpr_Expr :: !(Expr)} -- DataFieldPatExpr -------------------------------------------- data DataFieldPatExpr = DataFieldPatExpr_Ext {hsrange_DataFieldPatExpr_Ext :: !(Range),dataFieldPatExpr_DataFieldPatExpr_Ext :: !(DataFieldPatExpr),nm_DataFieldPatExpr_Ext :: !(HsName),patExpr_DataFieldPatExpr_Ext :: !(PatExpr)} | DataFieldPatExpr_Con {hsrange_DataFieldPatExpr_Con :: !(Range),nm_DataFieldPatExpr_Con :: !(HsName)} -- DataFields -------------------------------------------------- type DataFields = [DataField] -- Decl -------------------------------------------------------- data Decl = Decl_TySig {hsrange_Decl_TySig :: !(Range),nm_Decl_TySig :: !(HsName),tyExpr_Decl_TySig :: !(TyExpr)} | Decl_Val {hsrange_Decl_Val :: !(Range),patExpr_Decl_Val :: !(PatExpr),expr_Decl_Val :: !(Expr)} | Decl_Data {hsrange_Decl_Data :: !(Range),isNewtype_Decl_Data :: !(Bool),tyNm_Decl_Data :: !(HsName),tyVars_Decl_Data :: !(TyVars),constrs_Decl_Data :: !(DataConstrs),mbGenerInfo_Decl_Data :: !((Maybe Int))} | Decl_KiSig {hsrange_Decl_KiSig :: !(Range),nm_Decl_KiSig :: !(HsName),kiExpr_Decl_KiSig :: !(KiExpr)} | Decl_FFI {hsrange_Decl_FFI :: !(Range),callconv_Decl_FFI :: !(FFIWay),safety_Decl_FFI :: !(String),impEnt_Decl_FFI :: !(ForeignEnt),nm_Decl_FFI :: !(HsName),tyExpr_Decl_FFI :: !(TyExpr)} | Decl_Type {hsrange_Decl_Type :: !(Range),tyNm_Decl_Type :: !(HsName),tyExpr_Decl_Type :: !(TyExpr)} | Decl_FFE {hsrange_Decl_FFE :: !(Range),nm_Decl_FFE :: !(HsName),callconv_Decl_FFE :: !(FFIWay),expEnt_Decl_FFE :: !(ForeignEnt),expr_Decl_FFE :: !(Expr),tyExpr_Decl_FFE :: !(TyExpr)} | Decl_GenerRep {hsrange_Decl_GenerRep :: !(Range),maxArity_Decl_GenerRep :: !(Int),arity_Decl_GenerRep :: !(Int),tyNm_Decl_GenerRep :: !(HsName),conNmL_Decl_GenerRep :: !(([HsName])),recFldNmL_Decl_GenerRep :: !(([(HsName,[HsName])]))} | Decl_FusionDecl {hsrange_Decl_FusionDecl :: !(Range),fuseNm_Decl_FusionDecl :: !(HsName)} | Decl_FusionConv {hsrange_Decl_FusionConv :: !(Range),conNm_Decl_FusionConv :: !(HsName),absNm_Decl_FusionConv :: !(HsName)} | Decl_Class {hsrange_Decl_Class :: !(Range),clNm_Decl_Class :: !(HsName),tyPrExpr_Decl_Class :: !(TyExpr),funcDeps_Decl_Class :: !(FuncDeps),mbDefaultInstNm_Decl_Class :: !((Maybe HsName)),decls_Decl_Class :: !(Decls),generDerivs_Decl_Class :: !(([(HsName,HsName)]))} | Decl_Instance {hsrange_Decl_Instance :: !(Range),mbNmElim_Decl_Instance :: !((Maybe (HsName,Bool))),instVariant_Decl_Instance :: !(InstVariant),tyPrExpr_Decl_Instance :: !(TyExpr),decls_Decl_Instance :: !(Decls)} | Decl_InstanceIntro {hsrange_Decl_InstanceIntro :: !(Range),mbNmElim_Decl_InstanceIntro :: !((Maybe (HsName))),expr_Decl_InstanceIntro :: !(Expr),prExpr_Decl_InstanceIntro :: !(PrExpr)} | Decl_Default {hsrange_Decl_Default :: !(Range),nm_Decl_Default :: !(HsName),tyExprs_Decl_Default :: !(TyExprs)} -- Decls ------------------------------------------------------- type Decls = [Decl] -- Expr -------------------------------------------------------- data Expr = Expr_IConst {hsrange_Expr_IConst :: !(Range),int_Expr_IConst :: !(Int)} | Expr_CConst {hsrange_Expr_CConst :: !(Range),char_Expr_CConst :: !(Char)} | Expr_Con {hsrange_Expr_Con :: !(Range),nm_Expr_Con :: !(HsName)} | Expr_Var {hsrange_Expr_Var :: !(Range),nm_Expr_Var :: !(HsName)} | Expr_App {hsrange_Expr_App :: !(Range),func_Expr_App :: !(Expr),arg_Expr_App :: !(Expr)} | Expr_Let {hsrange_Expr_Let :: !(Range),isStrict_Expr_Let :: !(Bool),decls_Expr_Let :: !(Decls),body_Expr_Let :: !(Expr)} | Expr_Lam {hsrange_Expr_Lam :: !(Range),arg_Expr_Lam :: !(PatExpr),body_Expr_Lam :: !(Expr)} | Expr_AppTop {hsrange_Expr_AppTop :: !(Range),expr_Expr_AppTop :: !(Expr)} | Expr_Parens {hsrange_Expr_Parens :: !(Range),expr_Expr_Parens :: !(Expr)} | Expr_TypeAs {hsrange_Expr_TypeAs :: !(Range),isScoped_Expr_TypeAs :: !(Bool),tyExpr_Expr_TypeAs :: !(TyExpr),expr_Expr_TypeAs :: !(Expr)} | Expr_Ann {hsrange_Expr_Ann :: !(Range),ann_Expr_Ann :: !(ExprAnn),expr_Expr_Ann :: !(Expr)} | Expr_AppImpred {hsrange_Expr_AppImpred :: !(Range),func_Expr_AppImpred :: !(Expr),arg_Expr_AppImpred :: !(Expr)} | Expr_SConst {hsrange_Expr_SConst :: !(Range),str_Expr_SConst :: !(String)} | Expr_Case {hsrange_Expr_Case :: !(Range),expr_Expr_Case :: !(Expr),alts_Expr_Case :: !(CaseAlts),mbCaseIds_Expr_Case :: !((Maybe UIDS)),caseFailS_Expr_Case :: !(UIDS),isTupOfArg_Expr_Case :: !(Bool)} | Expr_DataFields {hsrange_Expr_DataFields :: !(Range),dataFieldExpr_Expr_DataFields :: !(DataFieldExpr)} | Expr_Rec {hsrange_Expr_Rec :: !(Range),recExpr_Expr_Rec :: !(RecExpr)} | Expr_Sel {hsrange_Expr_Sel :: !(Range),expr_Expr_Sel :: !(Expr),lbl_Expr_Sel :: !(HsName)} | Expr_Undefined {hsrange_Expr_Undefined :: !(Range)} | Expr_CaseAltFail {hsrange_Expr_CaseAltFail :: !(Range),caseId_Expr_CaseAltFail :: !(UID)} | Expr_AppImpl {hsrange_Expr_AppImpl :: !(Range),func_Expr_AppImpl :: !(Expr),argPr_Expr_AppImpl :: !(PrExpr),arg_Expr_AppImpl :: !(Expr)} | Expr_LamImpl {hsrange_Expr_LamImpl :: !(Range),argPr_Expr_LamImpl :: !(PrExpr),arg_Expr_LamImpl :: !(PatExpr),body_Expr_LamImpl :: !(Expr)} | Expr_DynVar {hsrange_Expr_DynVar :: !(Range),nm_Expr_DynVar :: !(HsName)} | Expr_IIConst {hsrange_Expr_IIConst :: !(Range),integer_Expr_IIConst :: !(Integer)} -- ExprAnn ----------------------------------------------------- data ExprAnn = ExprAnn_Empty {} -- FuncDep ----------------------------------------------------- data FuncDep = FuncDep_Dep {hsrange_FuncDep_Dep :: !(Range),fromTvs_FuncDep_Dep :: !(TyVars),toTvs_FuncDep_Dep :: !(TyVars)} -- FuncDeps ---------------------------------------------------- type FuncDeps = [FuncDep] -- KiExpr ------------------------------------------------------ data KiExpr = KiExpr_Con {hsrange_KiExpr_Con :: !(Range),nm_KiExpr_Con :: !(HsName)} | KiExpr_Var {hsrange_KiExpr_Var :: !(Range),nm_KiExpr_Var :: !(HsName)} | KiExpr_App {hsrange_KiExpr_App :: !(Range),func_KiExpr_App :: !(KiExpr),arg_KiExpr_App :: !(KiExpr)} | KiExpr_AppTop {hsrange_KiExpr_AppTop :: !(Range),kiExpr_KiExpr_AppTop :: !(KiExpr)} | KiExpr_Parens {hsrange_KiExpr_Parens :: !(Range),kiExpr_KiExpr_Parens :: !(KiExpr)} | KiExpr_Ann {hsrange_KiExpr_Ann :: !(Range),ann_KiExpr_Ann :: !(KiExprAnn),kiExpr_KiExpr_Ann :: !(KiExpr)} -- KiExprAnn --------------------------------------------------- data KiExprAnn = KiExprAnn_Empty {} -- MbTyExpr ---------------------------------------------------- type MbTyExpr = Maybe (TyExpr) -- PatExpr ----------------------------------------------------- data PatExpr = PatExpr_IConst {hsrange_PatExpr_IConst :: !(Range),int_PatExpr_IConst :: !(Int)} | PatExpr_CConst {hsrange_PatExpr_CConst :: !(Range),char_PatExpr_CConst :: !(Char)} | PatExpr_Con {hsrange_PatExpr_Con :: !(Range),nm_PatExpr_Con :: !(HsName)} | PatExpr_Var {hsrange_PatExpr_Var :: !(Range),nm_PatExpr_Var :: !(HsName)} | PatExpr_VarAs {hsrange_PatExpr_VarAs :: !(Range),nm_PatExpr_VarAs :: !(HsName),patExpr_PatExpr_VarAs :: !(PatExpr)} | PatExpr_App {hsrange_PatExpr_App :: !(Range),func_PatExpr_App :: !(PatExpr),arg_PatExpr_App :: !(PatExpr)} | PatExpr_AppTop {hsrange_PatExpr_AppTop :: !(Range),patExpr_PatExpr_AppTop :: !(PatExpr)} | PatExpr_Parens {hsrange_PatExpr_Parens :: !(Range),patExpr_PatExpr_Parens :: !(PatExpr)} | PatExpr_Ann {hsrange_PatExpr_Ann :: !(Range),ann_PatExpr_Ann :: !(PatExprAnn),patExpr_PatExpr_Ann :: !(PatExpr)} | PatExpr_TypeAs {hsrange_PatExpr_TypeAs :: !(Range),tyExpr_PatExpr_TypeAs :: !(TyExpr),patExpr_PatExpr_TypeAs :: !(PatExpr)} | PatExpr_SConst {hsrange_PatExpr_SConst :: !(Range),str_PatExpr_SConst :: !(String)} | PatExpr_Rec {hsrange_PatExpr_Rec :: !(Range),recPatExpr_PatExpr_Rec :: !(RecPatExpr)} | PatExpr_DataFields {hsrange_PatExpr_DataFields :: !(Range),dataFieldPatExpr_PatExpr_DataFields :: !(DataFieldPatExpr)} | PatExpr_Irrefutable {hsrange_PatExpr_Irrefutable :: !(Range),patExpr_PatExpr_Irrefutable :: !(PatExpr)} | PatExpr_Bang {hsrange_PatExpr_Bang :: !(Range),patExpr_PatExpr_Bang :: !(PatExpr)} | PatExpr_Expr {hsrange_PatExpr_Expr :: !(Range),expr_PatExpr_Expr :: !(Expr),mbConst_PatExpr_Expr :: !((Maybe SrcConst))} -- PatExprAnn -------------------------------------------------- data PatExprAnn = PatExprAnn_Empty {} -- PrExpr ------------------------------------------------------ data PrExpr = PrExpr_Class {hsrange_PrExpr_Class :: !(Range),nm_PrExpr_Class :: !(HsName),tyExprs_PrExpr_Class :: !(TyExprs)} | PrExpr_Arrow {hsrange_PrExpr_Arrow :: !(Range),arg_PrExpr_Arrow :: !(PrExpr),res_PrExpr_Arrow :: !(PrExpr)} | PrExpr_Forall {hsrange_PrExpr_Forall :: !(Range),tyVar_PrExpr_Forall :: !(HsName),prExpr_PrExpr_Forall :: !(PrExpr)} | PrExpr_Lacks {hsrange_PrExpr_Lacks :: !(Range),rowTyExpr_PrExpr_Lacks :: !(RowTyExpr),nm_PrExpr_Lacks :: !(HsName)} | PrExpr_DynVar {hsrange_PrExpr_DynVar :: !(Range),nm_PrExpr_DynVar :: !(HsName),tyExpr_PrExpr_DynVar :: !(TyExpr)} | PrExpr_Eq {hsrange_PrExpr_Eq :: !(Range),tyExpr1_PrExpr_Eq :: !(TyExpr),tyExpr2_PrExpr_Eq :: !(TyExpr)} -- PrExprs ----------------------------------------------------- type PrExprs = [PrExpr] -- RecExpr ----------------------------------------------------- data RecExpr = RecExpr_Empty {hsrange_RecExpr_Empty :: !(Range)} | RecExpr_Ext {hsrange_RecExpr_Ext :: !(Range),recExpr_RecExpr_Ext :: !(RecExpr),mbNm_RecExpr_Ext :: !((Maybe HsName)),expr_RecExpr_Ext :: !(Expr)} | RecExpr_Upd {hsrange_RecExpr_Upd :: !(Range),recExpr_RecExpr_Upd :: !(RecExpr),nm_RecExpr_Upd :: !(HsName),expr_RecExpr_Upd :: !(Expr)} | RecExpr_Expr {hsrange_RecExpr_Expr :: !(Range),expr_RecExpr_Expr :: !(Expr)} -- RecPatExpr -------------------------------------------------- data RecPatExpr = RecPatExpr_Empty {hsrange_RecPatExpr_Empty :: !(Range)} | RecPatExpr_Ext {hsrange_RecPatExpr_Ext :: !(Range),recPatExpr_RecPatExpr_Ext :: !(RecPatExpr),mbNm_RecPatExpr_Ext :: !((Maybe HsName)),patExpr_RecPatExpr_Ext :: !(PatExpr)} | RecPatExpr_Expr {hsrange_RecPatExpr_Expr :: !(Range),patExpr_RecPatExpr_Expr :: !(PatExpr)} -- RowTyExpr --------------------------------------------------- data RowTyExpr = RowTyExpr_Empty {hsrange_RowTyExpr_Empty :: !(Range)} | RowTyExpr_Ext {hsrange_RowTyExpr_Ext :: !(Range),rowTyExpr_RowTyExpr_Ext :: !(RowTyExpr),mbNm_RowTyExpr_Ext :: !((Maybe HsName)),tyExpr_RowTyExpr_Ext :: !(TyExpr)} | RowTyExpr_Var {hsrange_RowTyExpr_Var :: !(Range),nm_RowTyExpr_Var :: !(HsName)} -- TyExpr ------------------------------------------------------ data TyExpr = TyExpr_Con {hsrange_TyExpr_Con :: !(Range),nm_TyExpr_Con :: !(HsName)} | TyExpr_App {hsrange_TyExpr_App :: !(Range),func_TyExpr_App :: !(TyExpr),arg_TyExpr_App :: !(TyExpr)} | TyExpr_AppTop {hsrange_TyExpr_AppTop :: !(Range),tyExpr_TyExpr_AppTop :: !(TyExpr)} | TyExpr_Parens {hsrange_TyExpr_Parens :: !(Range),tyExpr_TyExpr_Parens :: !(TyExpr)} | TyExpr_Ann {hsrange_TyExpr_Ann :: !(Range),ann_TyExpr_Ann :: !(TyExprAnn),tyExpr_TyExpr_Ann :: !(TyExpr)} | TyExpr_Wild {hsrange_TyExpr_Wild :: !(Range)} | TyExpr_Mono {hsrange_TyExpr_Mono :: !(Range)} | TyExpr_Var {hsrange_TyExpr_Var :: !(Range),nm_TyExpr_Var :: !(HsName)} | TyExpr_VarWild {hsrange_TyExpr_VarWild :: !(Range),nm_TyExpr_VarWild :: !(HsName)} | TyExpr_Quant {hsrange_TyExpr_Quant :: !(Range),qu_TyExpr_Quant :: !(TyQu),tyVar_TyExpr_Quant :: !(HsName),tyExpr_TyExpr_Quant :: !(TyExpr)} | TyExpr_Row {hsrange_TyExpr_Row :: !(Range),rowTyExpr_TyExpr_Row :: !(RowTyExpr)} | TyExpr_Pred {hsrange_TyExpr_Pred :: !(Range),prExpr_TyExpr_Pred :: !(PrExpr)} | TyExpr_Impls {hsrange_TyExpr_Impls :: !(Range)} | TyExpr_NoImpls {hsrange_TyExpr_NoImpls :: !(Range)} | TyExpr_Lam {hsrange_TyExpr_Lam :: !(Range),tyVar_TyExpr_Lam :: !(HsName),tyExpr_TyExpr_Lam :: !(TyExpr)} -- TyExprAnn --------------------------------------------------- data TyExprAnn = TyExprAnn_Empty {} | TyExprAnn_Strictness {strictness_TyExprAnn_Strictness :: !(Strictness)} -- TyExprs ----------------------------------------------------- type TyExprs = [TyExpr] -- TyVar ------------------------------------------------------- data TyVar = TyVar_Var {hsrange_TyVar_Var :: !(Range),nm_TyVar_Var :: !(HsName)} -- TyVars ------------------------------------------------------ type TyVars = [TyVar]