uhc-light-1.1.9.3: src/UHC/Light/Compiler/EH.hs
-- UUAGC 0.9.52.2 (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]