    {-# LANGUAGE CPP #-}
    {-# LANGUAGE PatternSynonyms #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    -- |
    -- This module reexports a simplified view on "Language.Haskell.Exts.Syntax".
    -- The idea is to expose datatypes like
    --
    -- > data Name l = Ident l String | Symbol l String
    --
    -- using ghc's pattern synonyms:
    --
    -- > type Name = H.Name ()
    -- > pattern Ident a = H.Ident () a
    -- > pattern Symbol a = H.Symbol () a

    module Language.Haskell.Exts.Simple.Syntax (
        module Language.Haskell.Exts.Simple.Syntax,
        module Language.Haskell.Exts.Syntax
    ) where

    import qualified Language.Haskell.Exts.Syntax as H
    import Language.Haskell.Exts.Syntax (
        Boxed (..),
        Tool (..),
     )

    -- * Datatypes and Constructors

    -- ** `H.ModuleName`
    type ModuleName = H.ModuleName ()
    pattern $mModuleName :: forall {r}. ModuleName -> (String -> r) -> ((# #) -> r) -> r
    $bModuleName :: String -> ModuleName
    ModuleName a = H.ModuleName () (a :: String) :: ModuleName

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ModuleName #-}
    #endif

    -- ** `H.SpecialCon`
    type SpecialCon = H.SpecialCon ()
    pattern $mUnitCon :: forall {r}. SpecialCon -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUnitCon :: SpecialCon
    UnitCon = H.UnitCon () :: SpecialCon
    pattern $mListCon :: forall {r}. SpecialCon -> ((# #) -> r) -> ((# #) -> r) -> r
    $bListCon :: SpecialCon
    ListCon = H.ListCon () :: SpecialCon
    pattern $mFunCon :: forall {r}. SpecialCon -> ((# #) -> r) -> ((# #) -> r) -> r
    $bFunCon :: SpecialCon
    FunCon = H.FunCon () :: SpecialCon
    pattern $mTupleCon :: forall {r}. SpecialCon -> (Boxed -> Int -> r) -> ((# #) -> r) -> r
    $bTupleCon :: Boxed -> Int -> SpecialCon
    TupleCon a b = H.TupleCon () (a :: Boxed) (b :: Int) :: SpecialCon
    pattern $mCons :: forall {r}. SpecialCon -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCons :: SpecialCon
    Cons = H.Cons () :: SpecialCon
    pattern $mUnboxedSingleCon :: forall {r}. SpecialCon -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUnboxedSingleCon :: SpecialCon
    UnboxedSingleCon = H.UnboxedSingleCon () :: SpecialCon
    pattern $mExprHole :: forall {r}. SpecialCon -> ((# #) -> r) -> ((# #) -> r) -> r
    $bExprHole :: SpecialCon
    ExprHole = H.ExprHole () :: SpecialCon

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE UnitCon, ListCon, FunCon, TupleCon, Cons, UnboxedSingleCon, ExprHole #-}
    #endif

    -- ** `H.QName`
    type QName = H.QName ()
    pattern $mQual :: forall {r}. QName -> (ModuleName -> Name -> r) -> ((# #) -> r) -> r
    $bQual :: ModuleName -> Name -> QName
    Qual a b = H.Qual () (a :: ModuleName) (b :: Name) :: QName
    pattern $mUnQual :: forall {r}. QName -> (Name -> r) -> ((# #) -> r) -> r
    $bUnQual :: Name -> QName
    UnQual a = H.UnQual () (a :: Name) :: QName
    pattern $mSpecial :: forall {r}. QName -> (SpecialCon -> r) -> ((# #) -> r) -> r
    $bSpecial :: SpecialCon -> QName
    Special a = H.Special () (a :: SpecialCon) :: QName

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Qual, UnQual, Special #-}
    #endif

    -- ** `H.Name`
    type Name = H.Name ()
    pattern $mIdent :: forall {r}. Name -> (String -> r) -> ((# #) -> r) -> r
    $bIdent :: String -> Name
    Ident a = H.Ident () (a :: String) :: Name
    pattern $mSymbol :: forall {r}. Name -> (String -> r) -> ((# #) -> r) -> r
    $bSymbol :: String -> Name
    Symbol a = H.Symbol () (a :: String) :: Name

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Ident, Symbol #-}
    #endif

    -- ** `H.IPName`
    type IPName = H.IPName ()
    pattern $mIPDup :: forall {r}. IPName -> (String -> r) -> ((# #) -> r) -> r
    $bIPDup :: String -> IPName
    IPDup a = H.IPDup () (a :: String) :: IPName
    pattern $mIPLin :: forall {r}. IPName -> (String -> r) -> ((# #) -> r) -> r
    $bIPLin :: String -> IPName
    IPLin a = H.IPLin () (a :: String) :: IPName

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE IPDup, IPLin #-}
    #endif

    -- ** `H.QOp`
    type QOp = H.QOp ()
    pattern $mQVarOp :: forall {r}. QOp -> (QName -> r) -> ((# #) -> r) -> r
    $bQVarOp :: QName -> QOp
    QVarOp a = H.QVarOp () (a :: QName) :: QOp
    pattern $mQConOp :: forall {r}. QOp -> (QName -> r) -> ((# #) -> r) -> r
    $bQConOp :: QName -> QOp
    QConOp a = H.QConOp () (a :: QName) :: QOp

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE QVarOp, QConOp #-}
    #endif

    -- ** `H.Op`
    type Op = H.Op ()
    pattern $mVarOp :: forall {r}. Op -> (Name -> r) -> ((# #) -> r) -> r
    $bVarOp :: Name -> Op
    VarOp a = H.VarOp () (a :: Name) :: Op
    pattern $mConOp :: forall {r}. Op -> (Name -> r) -> ((# #) -> r) -> r
    $bConOp :: Name -> Op
    ConOp a = H.ConOp () (a :: Name) :: Op

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE VarOp, ConOp #-}
    #endif

    -- ** `H.CName`
    type CName = H.CName ()
    pattern $mVarName :: forall {r}. CName -> (Name -> r) -> ((# #) -> r) -> r
    $bVarName :: Name -> CName
    VarName a = H.VarName () (a :: Name) :: CName
    pattern $mConName :: forall {r}. CName -> (Name -> r) -> ((# #) -> r) -> r
    $bConName :: Name -> CName
    ConName a = H.ConName () (a :: Name) :: CName

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE VarName, ConName #-}
    #endif

    -- ** `H.Module`
    type Module = H.Module ()
    pattern $mModule :: forall {r}.
    Module
    -> (Maybe ModuleHead
        -> [ModulePragma] -> [ImportDecl] -> [Decl] -> r)
    -> ((# #) -> r)
    -> r
    $bModule :: Maybe ModuleHead
    -> [ModulePragma] -> [ImportDecl] -> [Decl] -> Module
    Module a b c d = H.Module () (a :: (Maybe ModuleHead)) (b :: [ModulePragma]) (c :: [ImportDecl]) (d :: [Decl]) :: Module
    pattern $mXmlPage :: forall {r}.
    Module
    -> (ModuleName
        -> [ModulePragma] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> r)
    -> ((# #) -> r)
    -> r
    $bXmlPage :: ModuleName
    -> [ModulePragma]
    -> XName
    -> [XAttr]
    -> Maybe Exp
    -> [Exp]
    -> Module
    XmlPage a b c d e f = H.XmlPage () (a :: ModuleName) (b :: [ModulePragma]) (c :: XName) (d :: [XAttr]) (e :: (Maybe Exp)) (f :: [Exp]) :: Module
    pattern $mXmlHybrid :: forall {r}.
    Module
    -> (Maybe ModuleHead
        -> [ModulePragma]
        -> [ImportDecl]
        -> [Decl]
        -> XName
        -> [XAttr]
        -> Maybe Exp
        -> [Exp]
        -> r)
    -> ((# #) -> r)
    -> r
    $bXmlHybrid :: Maybe ModuleHead
    -> [ModulePragma]
    -> [ImportDecl]
    -> [Decl]
    -> XName
    -> [XAttr]
    -> Maybe Exp
    -> [Exp]
    -> Module
    XmlHybrid a b c d e f g h = H.XmlHybrid () (a :: (Maybe ModuleHead)) (b :: [ModulePragma]) (c :: [ImportDecl]) (d :: [Decl]) (e :: XName) (f :: [XAttr]) (g :: (Maybe Exp)) (h :: [Exp]) :: Module

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Module, XmlPage, XmlHybrid #-}
    #endif

    -- ** `H.ModuleHead`
    type ModuleHead = H.ModuleHead ()
    pattern $mModuleHead :: forall {r}.
    ModuleHead
    -> (ModuleName -> Maybe WarningText -> Maybe ExportSpecList -> r)
    -> ((# #) -> r)
    -> r
    $bModuleHead :: ModuleName
    -> Maybe WarningText -> Maybe ExportSpecList -> ModuleHead
    ModuleHead a b c = H.ModuleHead () (a :: ModuleName) (b :: (Maybe WarningText)) (c :: (Maybe ExportSpecList)) :: ModuleHead

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ModuleHead #-}
    #endif

    -- ** `H.ExportSpecList`
    type ExportSpecList = H.ExportSpecList ()
    pattern $mExportSpecList :: forall {r}.
    ExportSpecList -> ([ExportSpec] -> r) -> ((# #) -> r) -> r
    $bExportSpecList :: [ExportSpec] -> ExportSpecList
    ExportSpecList a = H.ExportSpecList () (a :: [ExportSpec]) :: ExportSpecList

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ExportSpecList #-}
    #endif

    -- ** `H.ExportSpec`
    type ExportSpec = H.ExportSpec ()
    pattern $mEVar :: forall {r}. ExportSpec -> (QName -> r) -> ((# #) -> r) -> r
    $bEVar :: QName -> ExportSpec
    EVar a = H.EVar () (a :: QName) :: ExportSpec
    pattern $mEAbs :: forall {r}.
    ExportSpec -> (Namespace -> QName -> r) -> ((# #) -> r) -> r
    $bEAbs :: Namespace -> QName -> ExportSpec
    EAbs a b = H.EAbs () (a :: Namespace) (b :: QName) :: ExportSpec
    pattern $mEThingWith :: forall {r}.
    ExportSpec
    -> (EWildcard -> QName -> [CName] -> r) -> ((# #) -> r) -> r
    $bEThingWith :: EWildcard -> QName -> [CName] -> ExportSpec
    EThingWith a b c = H.EThingWith () (a :: EWildcard) (b :: QName) (c :: [CName]) :: ExportSpec
    pattern $mEModuleContents :: forall {r}. ExportSpec -> (ModuleName -> r) -> ((# #) -> r) -> r
    $bEModuleContents :: ModuleName -> ExportSpec
    EModuleContents a = H.EModuleContents () (a :: ModuleName) :: ExportSpec

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE EVar, EAbs, EThingWith, EModuleContents #-}
    #endif

    -- ** `H.EWildcard`
    type EWildcard = H.EWildcard ()
    pattern $mNoWildcard :: forall {r}. EWildcard -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNoWildcard :: EWildcard
    NoWildcard = H.NoWildcard () :: EWildcard
    pattern $mEWildcard :: forall {r}. EWildcard -> (Int -> r) -> ((# #) -> r) -> r
    $bEWildcard :: Int -> EWildcard
    EWildcard a = H.EWildcard () (a :: Int) :: EWildcard

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE NoWildcard, EWildcard #-}
    #endif

    -- ** `H.Namespace`
    type Namespace = H.Namespace ()
    pattern $mNoNamespace :: forall {r}. Namespace -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNoNamespace :: Namespace
    NoNamespace = H.NoNamespace () :: Namespace
    pattern $mTypeNamespace :: forall {r}. Namespace -> ((# #) -> r) -> ((# #) -> r) -> r
    $bTypeNamespace :: Namespace
    TypeNamespace = H.TypeNamespace () :: Namespace
    pattern $mPatternNamespace :: forall {r}. Namespace -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPatternNamespace :: Namespace
    PatternNamespace = H.PatternNamespace () :: Namespace

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE NoNamespace, TypeNamespace, PatternNamespace #-}
    #endif

    -- ** `H.ImportDecl`
    type ImportDecl = H.ImportDecl ()
    pattern $mImportDecl :: forall {r}.
    ImportDecl
    -> (ModuleName
        -> Bool
        -> Bool
        -> Bool
        -> Maybe String
        -> Maybe ModuleName
        -> Maybe (ImportSpecList ())
        -> r)
    -> ((# #) -> r)
    -> r
    $bImportDecl :: ModuleName
    -> Bool
    -> Bool
    -> Bool
    -> Maybe String
    -> Maybe ModuleName
    -> Maybe (ImportSpecList ())
    -> ImportDecl
    ImportDecl { ImportDecl -> ModuleName
    importModule, ImportDecl -> Bool
    importQualified, ImportDecl -> Bool
    importSrc, ImportDecl -> Bool
    importSafe, ImportDecl -> Maybe String
    importPkg, ImportDecl -> Maybe ModuleName
    importAs, ImportDecl -> Maybe (ImportSpecList ())
    importSpecs } =
        H.ImportDecl () importModule importQualified importSrc importSafe importPkg importAs importSpecs :: ImportDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ImportDecl #-}
    #endif

    -- ** `H.ImportSpecList`
    type ImportSpecList = H.ImportSpecList ()
    pattern $mImportSpecList :: forall {r}.
    ImportSpecList ()
    -> (Bool -> [ImportSpec] -> r) -> ((# #) -> r) -> r
    $bImportSpecList :: Bool -> [ImportSpec] -> ImportSpecList ()
    ImportSpecList a b = H.ImportSpecList () (a :: Bool) (b :: [ImportSpec]) :: ImportSpecList

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ImportSpecList #-}
    #endif

    -- ** `H.ImportSpec`
    type ImportSpec = H.ImportSpec ()
    pattern $mIVar :: forall {r}. ImportSpec -> (Name -> r) -> ((# #) -> r) -> r
    $bIVar :: Name -> ImportSpec
    IVar a = H.IVar () (a :: Name) :: ImportSpec
    pattern $mIAbs :: forall {r}.
    ImportSpec -> (Namespace -> Name -> r) -> ((# #) -> r) -> r
    $bIAbs :: Namespace -> Name -> ImportSpec
    IAbs a b = H.IAbs () (a :: Namespace) (b :: Name) :: ImportSpec
    pattern $mIThingAll :: forall {r}. ImportSpec -> (Name -> r) -> ((# #) -> r) -> r
    $bIThingAll :: Name -> ImportSpec
    IThingAll a = H.IThingAll () (a :: Name) :: ImportSpec
    pattern $mIThingWith :: forall {r}.
    ImportSpec -> (Name -> [CName] -> r) -> ((# #) -> r) -> r
    $bIThingWith :: Name -> [CName] -> ImportSpec
    IThingWith a b = H.IThingWith () (a :: Name) (b :: [CName]) :: ImportSpec

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE IVar, IAbs, IThingAll, IThingWith #-}
    #endif

    -- ** `H.Assoc`
    type Assoc = H.Assoc ()
    pattern $mAssocNone :: forall {r}. Assoc -> ((# #) -> r) -> ((# #) -> r) -> r
    $bAssocNone :: Assoc
    AssocNone = H.AssocNone () :: Assoc
    pattern $mAssocLeft :: forall {r}. Assoc -> ((# #) -> r) -> ((# #) -> r) -> r
    $bAssocLeft :: Assoc
    AssocLeft = H.AssocLeft () :: Assoc
    pattern $mAssocRight :: forall {r}. Assoc -> ((# #) -> r) -> ((# #) -> r) -> r
    $bAssocRight :: Assoc
    AssocRight = H.AssocRight () :: Assoc

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE AssocNone, AssocLeft, AssocRight #-}
    #endif

    -- ** `H.Decl`
    type Decl = H.Decl ()
    pattern $mTypeDecl :: forall {r}. Decl -> (DeclHead -> Type -> r) -> ((# #) -> r) -> r
    $bTypeDecl :: DeclHead -> Type -> Decl
    TypeDecl a b = H.TypeDecl () (a :: DeclHead) (b :: Type) :: Decl
    pattern $mTypeFamDecl :: forall {r}.
    Decl
    -> (DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> r)
    -> ((# #) -> r)
    -> r
    $bTypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> Decl
    TypeFamDecl a b c = H.TypeFamDecl () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) :: Decl
    pattern $mClosedTypeFamDecl :: forall {r}.
    Decl
    -> (DeclHead
        -> Maybe ResultSig -> Maybe InjectivityInfo -> [TypeEqn] -> r)
    -> ((# #) -> r)
    -> r
    $bClosedTypeFamDecl :: DeclHead
    -> Maybe ResultSig -> Maybe InjectivityInfo -> [TypeEqn] -> Decl
    ClosedTypeFamDecl a b c d = H.ClosedTypeFamDecl () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) (d :: [TypeEqn]) :: Decl
    pattern $mDataDecl :: forall {r}.
    Decl
    -> (DataOrNew
        -> Maybe Context -> DeclHead -> [QualConDecl] -> [Deriving] -> r)
    -> ((# #) -> r)
    -> r
    $bDataDecl :: DataOrNew
    -> Maybe Context -> DeclHead -> [QualConDecl] -> [Deriving] -> Decl
    DataDecl a b c d e = H.DataDecl () (a :: DataOrNew) (b :: (Maybe Context)) (c :: DeclHead) (d :: [QualConDecl]) (e :: [Deriving]) :: Decl
    pattern $mGDataDecl :: forall {r}.
    Decl
    -> (DataOrNew
        -> Maybe Context
        -> DeclHead
        -> Maybe Type
        -> [GadtDecl]
        -> [Deriving]
        -> r)
    -> ((# #) -> r)
    -> r
    $bGDataDecl :: DataOrNew
    -> Maybe Context
    -> DeclHead
    -> Maybe Type
    -> [GadtDecl]
    -> [Deriving]
    -> Decl
    GDataDecl a b c d e f = H.GDataDecl () (a :: DataOrNew) (b :: (Maybe Context)) (c :: DeclHead) (d :: (Maybe Kind)) (e :: [GadtDecl]) (f :: [Deriving]) :: Decl
    pattern $mDataFamDecl :: forall {r}.
    Decl
    -> (Maybe Context -> DeclHead -> Maybe ResultSig -> r)
    -> ((# #) -> r)
    -> r
    $bDataFamDecl :: Maybe Context -> DeclHead -> Maybe ResultSig -> Decl
    DataFamDecl a b c = H.DataFamDecl () (a :: (Maybe Context)) (b :: DeclHead) (c :: (Maybe ResultSig)) :: Decl
    pattern $mTypeInsDecl :: forall {r}. Decl -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bTypeInsDecl :: Type -> Type -> Decl
    TypeInsDecl a b = H.TypeInsDecl () (a :: Type) (b :: Type) :: Decl
    pattern $mDataInsDecl :: forall {r}.
    Decl
    -> (DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> r)
    -> ((# #) -> r)
    -> r
    $bDataInsDecl :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> Decl
    DataInsDecl a b c d = H.DataInsDecl () (a :: DataOrNew) (b :: Type) (c :: [QualConDecl]) (d :: [Deriving]) :: Decl
    pattern $mGDataInsDecl :: forall {r}.
    Decl
    -> (DataOrNew
        -> Type -> Maybe Type -> [GadtDecl] -> [Deriving] -> r)
    -> ((# #) -> r)
    -> r
    $bGDataInsDecl :: DataOrNew -> Type -> Maybe Type -> [GadtDecl] -> [Deriving] -> Decl
    GDataInsDecl a b c d e = H.GDataInsDecl () (a :: DataOrNew) (b :: Type) (c :: (Maybe Kind)) (d :: [GadtDecl]) (e :: [Deriving]) :: Decl
    pattern $mClassDecl :: forall {r}.
    Decl
    -> (Maybe Context
        -> DeclHead -> [FunDep] -> Maybe [ClassDecl] -> r)
    -> ((# #) -> r)
    -> r
    $bClassDecl :: Maybe Context -> DeclHead -> [FunDep] -> Maybe [ClassDecl] -> Decl
    ClassDecl a b c d = H.ClassDecl () (a :: (Maybe Context)) (b :: DeclHead) (c :: [FunDep]) (d :: (Maybe [ClassDecl])) :: Decl
    pattern $mInstDecl :: forall {r}.
    Decl
    -> (Maybe Overlap -> InstRule -> Maybe [InstDecl] -> r)
    -> ((# #) -> r)
    -> r
    $bInstDecl :: Maybe Overlap -> InstRule -> Maybe [InstDecl] -> Decl
    InstDecl a b c = H.InstDecl () (a :: (Maybe Overlap)) (b :: InstRule) (c :: (Maybe [InstDecl])) :: Decl
    pattern $mDerivDecl :: forall {r}.
    Decl
    -> (Maybe DerivStrategy -> Maybe Overlap -> InstRule -> r)
    -> ((# #) -> r)
    -> r
    $bDerivDecl :: Maybe DerivStrategy -> Maybe Overlap -> InstRule -> Decl
    DerivDecl a b c = H.DerivDecl () (a :: (Maybe DerivStrategy)) (b :: (Maybe Overlap)) (c :: InstRule) :: Decl
    pattern $mInfixDecl :: forall {r}.
    Decl -> (Assoc -> Maybe Int -> [Op] -> r) -> ((# #) -> r) -> r
    $bInfixDecl :: Assoc -> Maybe Int -> [Op] -> Decl
    InfixDecl a b c = H.InfixDecl () (a :: Assoc) (b :: (Maybe Int)) (c :: [Op]) :: Decl
    pattern $mDefaultDecl :: forall {r}. Decl -> ([Type] -> r) -> ((# #) -> r) -> r
    $bDefaultDecl :: [Type] -> Decl
    DefaultDecl a = H.DefaultDecl () (a :: [Type]) :: Decl
    pattern $mSpliceDecl :: forall {r}. Decl -> (Exp -> r) -> ((# #) -> r) -> r
    $bSpliceDecl :: Exp -> Decl
    SpliceDecl a = H.SpliceDecl () (a :: Exp) :: Decl
    pattern $mTSpliceDecl :: forall {r}. Decl -> (Exp -> r) -> ((# #) -> r) -> r
    $bTSpliceDecl :: Exp -> Decl
    TSpliceDecl a = H.TSpliceDecl () (a :: Exp) :: Decl
    pattern $mTypeSig :: forall {r}. Decl -> ([Name] -> Type -> r) -> ((# #) -> r) -> r
    $bTypeSig :: [Name] -> Type -> Decl
    TypeSig a b = H.TypeSig () (a :: [Name]) (b :: Type) :: Decl
    pattern $mPatSynSig :: forall {r}.
    Decl
    -> ([Name]
        -> Maybe [TyVarBind]
        -> Maybe Context
        -> Maybe [TyVarBind]
        -> Maybe Context
        -> Type
        -> r)
    -> ((# #) -> r)
    -> r
    $bPatSynSig :: [Name]
    -> Maybe [TyVarBind]
    -> Maybe Context
    -> Maybe [TyVarBind]
    -> Maybe Context
    -> Type
    -> Decl
    PatSynSig a b c d e f = H.PatSynSig () (a :: [Name]) (b :: (Maybe [TyVarBind])) (c :: (Maybe Context)) (d :: (Maybe [TyVarBind])) (e :: (Maybe Context)) (f :: Type) :: Decl
    pattern $mFunBind :: forall {r}. Decl -> ([Match] -> r) -> ((# #) -> r) -> r
    $bFunBind :: [Match] -> Decl
    FunBind a = H.FunBind () (a :: [Match]) :: Decl
    pattern $mPatBind :: forall {r}.
    Decl -> (Pat -> Rhs -> Maybe Binds -> r) -> ((# #) -> r) -> r
    $bPatBind :: Pat -> Rhs -> Maybe Binds -> Decl
    PatBind a b c = H.PatBind () (a :: Pat) (b :: Rhs) (c :: (Maybe Binds)) :: Decl
    pattern $mPatSyn :: forall {r}.
    Decl
    -> (Pat -> Pat -> PatternSynDirection -> r) -> ((# #) -> r) -> r
    $bPatSyn :: Pat -> Pat -> PatternSynDirection -> Decl
    PatSyn a b c = H.PatSyn () (a :: Pat) (b :: Pat) (c :: PatternSynDirection) :: Decl
    pattern $mForImp :: forall {r}.
    Decl
    -> (CallConv -> Maybe Safety -> Maybe String -> Name -> Type -> r)
    -> ((# #) -> r)
    -> r
    $bForImp :: CallConv -> Maybe Safety -> Maybe String -> Name -> Type -> Decl
    ForImp a b c d e = H.ForImp () (a :: CallConv) (b :: (Maybe Safety)) (c :: (Maybe String)) (d :: Name) (e :: Type) :: Decl
    pattern $mForExp :: forall {r}.
    Decl
    -> (CallConv -> Maybe String -> Name -> Type -> r)
    -> ((# #) -> r)
    -> r
    $bForExp :: CallConv -> Maybe String -> Name -> Type -> Decl
    ForExp a b c d = H.ForExp () (a :: CallConv) (b :: (Maybe String)) (c :: Name) (d :: Type) :: Decl
    pattern $mRulePragmaDecl :: forall {r}. Decl -> ([Rule] -> r) -> ((# #) -> r) -> r
    $bRulePragmaDecl :: [Rule] -> Decl
    RulePragmaDecl a = H.RulePragmaDecl () (a :: [Rule]) :: Decl
    pattern $mDeprPragmaDecl :: forall {r}. Decl -> ([([Name], String)] -> r) -> ((# #) -> r) -> r
    $bDeprPragmaDecl :: [([Name], String)] -> Decl
    DeprPragmaDecl a = H.DeprPragmaDecl () (a :: [([Name], String)]) :: Decl
    pattern $mWarnPragmaDecl :: forall {r}. Decl -> ([([Name], String)] -> r) -> ((# #) -> r) -> r
    $bWarnPragmaDecl :: [([Name], String)] -> Decl
    WarnPragmaDecl a = H.WarnPragmaDecl () (a :: [([Name], String)]) :: Decl
    pattern $mInlineSig :: forall {r}.
    Decl
    -> (Bool -> Maybe Activation -> QName -> r) -> ((# #) -> r) -> r
    $bInlineSig :: Bool -> Maybe Activation -> QName -> Decl
    InlineSig a b c = H.InlineSig () (a :: Bool) (b :: (Maybe Activation)) (c :: QName) :: Decl
    pattern $mInlineConlikeSig :: forall {r}.
    Decl -> (Maybe Activation -> QName -> r) -> ((# #) -> r) -> r
    $bInlineConlikeSig :: Maybe Activation -> QName -> Decl
    InlineConlikeSig a b = H.InlineConlikeSig () (a :: (Maybe Activation)) (b :: QName) :: Decl
    pattern $mSpecSig :: forall {r}.
    Decl
    -> (Maybe Activation -> QName -> [Type] -> r) -> ((# #) -> r) -> r
    $bSpecSig :: Maybe Activation -> QName -> [Type] -> Decl
    SpecSig a b c = H.SpecSig () (a :: (Maybe Activation)) (b :: QName) (c :: [Type]) :: Decl
    pattern $mSpecInlineSig :: forall {r}.
    Decl
    -> (Bool -> Maybe Activation -> QName -> [Type] -> r)
    -> ((# #) -> r)
    -> r
    $bSpecInlineSig :: Bool -> Maybe Activation -> QName -> [Type] -> Decl
    SpecInlineSig a b c d = H.SpecInlineSig () (a :: Bool) (b :: (Maybe Activation)) (c :: QName) (d :: [Type]) :: Decl
    pattern $mInstSig :: forall {r}. Decl -> (InstRule -> r) -> ((# #) -> r) -> r
    $bInstSig :: InstRule -> Decl
    InstSig a = H.InstSig () (a :: InstRule) :: Decl
    pattern $mAnnPragma :: forall {r}. Decl -> (Annotation -> r) -> ((# #) -> r) -> r
    $bAnnPragma :: Annotation -> Decl
    AnnPragma a = H.AnnPragma () (a :: Annotation) :: Decl
    pattern $mMinimalPragma :: forall {r}.
    Decl -> (Maybe BooleanFormula -> r) -> ((# #) -> r) -> r
    $bMinimalPragma :: Maybe BooleanFormula -> Decl
    MinimalPragma a = H.MinimalPragma () (a :: (Maybe BooleanFormula)) :: Decl
    pattern $mRoleAnnotDecl :: forall {r}. Decl -> (QName -> [Role] -> r) -> ((# #) -> r) -> r
    $bRoleAnnotDecl :: QName -> [Role] -> Decl
    RoleAnnotDecl a b = H.RoleAnnotDecl () (a :: QName) (b :: [Role]) :: Decl
    pattern $mCompletePragma :: forall {r}.
    Decl -> ([Name] -> Maybe QName -> r) -> ((# #) -> r) -> r
    $bCompletePragma :: [Name] -> Maybe QName -> Decl
    CompletePragma a b = H.CompletePragma () (a :: [Name]) (b :: (Maybe QName)) :: Decl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE TypeDecl, TypeFamDecl, ClosedTypeFamDecl, DataDecl, GDataDecl,
                 DataFamDecl, TypeInsDecl, DataInsDecl, GDataInsDecl, ClassDecl, InstDecl,
                 DerivDecl, InfixDecl, DefaultDecl, SpliceDecl, TSpliceDecl, TypeSig,
                 PatSynSig, FunBind, PatBind, PatSyn, ForImp, ForExp, RulePragmaDecl,
                 DeprPragmaDecl, WarnPragmaDecl, InlineSig, InlineConlikeSig, SpecSig,
                 SpecInlineSig, InstSig, AnnPragma, MinimalPragma, RoleAnnotDecl,
                 CompletePragma #-}
    #endif

    -- ** `H.PatternSynDirection`
    type PatternSynDirection = H.PatternSynDirection ()
    pattern $mUnidirectional :: forall {r}.
    PatternSynDirection -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUnidirectional :: PatternSynDirection
    Unidirectional = H.Unidirectional :: PatternSynDirection
    pattern $mImplicitBidirectional :: forall {r}.
    PatternSynDirection -> ((# #) -> r) -> ((# #) -> r) -> r
    $bImplicitBidirectional :: PatternSynDirection
    ImplicitBidirectional = H.ImplicitBidirectional :: PatternSynDirection
    pattern $mExplicitBidirectional :: forall {r}.
    PatternSynDirection -> ([Decl] -> r) -> ((# #) -> r) -> r
    $bExplicitBidirectional :: [Decl] -> PatternSynDirection
    ExplicitBidirectional a = H.ExplicitBidirectional () (a :: [Decl]) :: PatternSynDirection

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Unidirectional, ImplicitBidirectional, ExplicitBidirectional #-}
    #endif

    -- ** `H.TypeEqn`
    type TypeEqn = H.TypeEqn ()
    pattern $mTypeEqn :: forall {r}. TypeEqn -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bTypeEqn :: Type -> Type -> TypeEqn
    TypeEqn a b = H.TypeEqn () (a :: Type) (b :: Type) :: TypeEqn

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE TypeEqn #-}
    #endif

    -- ** `H.Annotation`
    type Annotation = H.Annotation ()
    pattern $mAnn :: forall {r}. Annotation -> (Name -> Exp -> r) -> ((# #) -> r) -> r
    $bAnn :: Name -> Exp -> Annotation
    Ann a b = H.Ann () (a :: Name) (b :: Exp) :: Annotation
    pattern $mTypeAnn :: forall {r}. Annotation -> (Name -> Exp -> r) -> ((# #) -> r) -> r
    $bTypeAnn :: Name -> Exp -> Annotation
    TypeAnn a b = H.TypeAnn () (a :: Name) (b :: Exp) :: Annotation
    pattern $mModuleAnn :: forall {r}. Annotation -> (Exp -> r) -> ((# #) -> r) -> r
    $bModuleAnn :: Exp -> Annotation
    ModuleAnn a = H.ModuleAnn () (a :: Exp) :: Annotation

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Ann, TypeAnn, ModuleAnn #-}
    #endif

    -- ** `H.BooleanFormula`
    type BooleanFormula = H.BooleanFormula ()
    pattern $mVarFormula :: forall {r}. BooleanFormula -> (Name -> r) -> ((# #) -> r) -> r
    $bVarFormula :: Name -> BooleanFormula
    VarFormula a = H.VarFormula () (a :: Name) :: BooleanFormula
    pattern $mAndFormula :: forall {r}.
    BooleanFormula -> ([BooleanFormula] -> r) -> ((# #) -> r) -> r
    $bAndFormula :: [BooleanFormula] -> BooleanFormula
    AndFormula a = H.AndFormula () (a :: [BooleanFormula]) :: BooleanFormula
    pattern $mOrFormula :: forall {r}.
    BooleanFormula -> ([BooleanFormula] -> r) -> ((# #) -> r) -> r
    $bOrFormula :: [BooleanFormula] -> BooleanFormula
    OrFormula a = H.OrFormula () (a :: [BooleanFormula]) :: BooleanFormula
    pattern $mParenFormula :: forall {r}.
    BooleanFormula -> (BooleanFormula -> r) -> ((# #) -> r) -> r
    $bParenFormula :: BooleanFormula -> BooleanFormula
    ParenFormula a = H.ParenFormula () (a :: BooleanFormula) :: BooleanFormula

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE VarFormula, AndFormula, OrFormula, ParenFormula #-}
    #endif

    -- ** `H.Role`
    type Role = H.Role ()
    pattern $mNominal :: forall {r}. Role -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNominal :: Role
    Nominal = H.Nominal () :: Role
    pattern $mRepresentational :: forall {r}. Role -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRepresentational :: Role
    Representational = H.Representational () :: Role
    pattern $mPhantom :: forall {r}. Role -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPhantom :: Role
    Phantom = H.Phantom () :: Role
    pattern $mRoleWildcard :: forall {r}. Role -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRoleWildcard :: Role
    RoleWildcard = H.RoleWildcard () :: Role

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Nominal, Representational, Phantom, RoleWildcard #-}
    #endif

    -- ** `H.DataOrNew`
    type DataOrNew = H.DataOrNew ()
    pattern $mDataType :: forall {r}. DataOrNew -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDataType :: DataOrNew
    DataType = H.DataType () :: DataOrNew
    pattern $mNewType :: forall {r}. DataOrNew -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNewType :: DataOrNew
    NewType = H.NewType () :: DataOrNew

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE DataType, NewType #-}
    #endif

    -- ** `H.InjectivityInfo`
    type InjectivityInfo = H.InjectivityInfo ()
    pattern $mInjectivityInfo :: forall {r}.
    InjectivityInfo -> (Name -> [Name] -> r) -> ((# #) -> r) -> r
    $bInjectivityInfo :: Name -> [Name] -> InjectivityInfo
    InjectivityInfo a b = H.InjectivityInfo () (a :: Name) (b :: [Name]) :: InjectivityInfo

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE InjectivityInfo #-}
    #endif

    -- ** `H.ResultSig`
    type ResultSig = H.ResultSig ()
    pattern $mKindSig :: forall {r}. ResultSig -> (Type -> r) -> ((# #) -> r) -> r
    $bKindSig :: Type -> ResultSig
    KindSig a = H.KindSig () (a :: Kind) :: ResultSig
    pattern $mTyVarSig :: forall {r}. ResultSig -> (TyVarBind -> r) -> ((# #) -> r) -> r
    $bTyVarSig :: TyVarBind -> ResultSig
    TyVarSig a = H.TyVarSig () (a :: TyVarBind) :: ResultSig

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE KindSig, TyVarSig #-}
    #endif

    -- ** `H.DeclHead`
    type DeclHead = H.DeclHead ()
    pattern $mDHead :: forall {r}. DeclHead -> (Name -> r) -> ((# #) -> r) -> r
    $bDHead :: Name -> DeclHead
    DHead a = H.DHead () (a :: Name) :: DeclHead
    pattern $mDHInfix :: forall {r}.
    DeclHead -> (TyVarBind -> Name -> r) -> ((# #) -> r) -> r
    $bDHInfix :: TyVarBind -> Name -> DeclHead
    DHInfix a b = H.DHInfix () (a :: TyVarBind) (b :: Name) :: DeclHead
    pattern $mDHParen :: forall {r}. DeclHead -> (DeclHead -> r) -> ((# #) -> r) -> r
    $bDHParen :: DeclHead -> DeclHead
    DHParen a = H.DHParen () (a :: DeclHead) :: DeclHead
    pattern $mDHApp :: forall {r}.
    DeclHead -> (DeclHead -> TyVarBind -> r) -> ((# #) -> r) -> r
    $bDHApp :: DeclHead -> TyVarBind -> DeclHead
    DHApp a b = H.DHApp () (a :: DeclHead) (b :: TyVarBind) :: DeclHead

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE DHead, DHInfix, DHParen, DHApp #-}
    #endif

    -- ** `H.InstRule`
    type InstRule = H.InstRule ()
    pattern $mIRule :: forall {r}.
    InstRule
    -> (Maybe [TyVarBind] -> Maybe Context -> InstHead -> r)
    -> ((# #) -> r)
    -> r
    $bIRule :: Maybe [TyVarBind] -> Maybe Context -> InstHead -> InstRule
    IRule a b c = H.IRule () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: InstHead) :: InstRule
    pattern $mIParen :: forall {r}. InstRule -> (InstRule -> r) -> ((# #) -> r) -> r
    $bIParen :: InstRule -> InstRule
    IParen a = H.IParen () (a :: InstRule) :: InstRule

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE IRule, IParen #-}
    #endif

    -- ** `H.InstHead`
    type InstHead = H.InstHead ()
    pattern $mIHCon :: forall {r}. InstHead -> (QName -> r) -> ((# #) -> r) -> r
    $bIHCon :: QName -> InstHead
    IHCon a = H.IHCon () (a :: QName) :: InstHead
    pattern $mIHInfix :: forall {r}. InstHead -> (Type -> QName -> r) -> ((# #) -> r) -> r
    $bIHInfix :: Type -> QName -> InstHead
    IHInfix a b = H.IHInfix () (a :: Type) (b :: QName) :: InstHead
    pattern $mIHParen :: forall {r}. InstHead -> (InstHead -> r) -> ((# #) -> r) -> r
    $bIHParen :: InstHead -> InstHead
    IHParen a = H.IHParen () (a :: InstHead) :: InstHead
    pattern $mIHApp :: forall {r}.
    InstHead -> (InstHead -> Type -> r) -> ((# #) -> r) -> r
    $bIHApp :: InstHead -> Type -> InstHead
    IHApp a b = H.IHApp () (a :: InstHead) (b :: Type) :: InstHead

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE IHCon, IHInfix, IHParen, IHApp #-}
    #endif

    -- ** `H.Deriving`
    type Deriving = H.Deriving ()
    pattern $mDeriving :: forall {r}.
    Deriving
    -> (Maybe DerivStrategy -> [InstRule] -> r) -> ((# #) -> r) -> r
    $bDeriving :: Maybe DerivStrategy -> [InstRule] -> Deriving
    Deriving a b = H.Deriving () (a :: (Maybe DerivStrategy)) (b :: [InstRule]) :: Deriving

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Deriving #-}
    #endif

    -- ** `H.DerivStrategy`
    type DerivStrategy = H.DerivStrategy ()
    pattern $mDerivStock :: forall {r}. DerivStrategy -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDerivStock :: DerivStrategy
    DerivStock = H.DerivStock () :: DerivStrategy
    pattern $mDerivAnyclass :: forall {r}. DerivStrategy -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDerivAnyclass :: DerivStrategy
    DerivAnyclass = H.DerivAnyclass () :: DerivStrategy
    pattern $mDerivNewtype :: forall {r}. DerivStrategy -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDerivNewtype :: DerivStrategy
    DerivNewtype = H.DerivNewtype () :: DerivStrategy
    pattern $mDerivVia :: forall {r}. DerivStrategy -> (Type -> r) -> ((# #) -> r) -> r
    $bDerivVia :: Type -> DerivStrategy
    DerivVia a = H.DerivVia () (a :: Type) :: DerivStrategy

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE DerivStock, DerivAnyclass, DerivNewtype, DerivVia #-}
    #endif

    -- ** `H.Binds`
    type Binds = H.Binds ()
    pattern $mBDecls :: forall {r}. Binds -> ([Decl] -> r) -> ((# #) -> r) -> r
    $bBDecls :: [Decl] -> Binds
    BDecls a = H.BDecls () (a :: [Decl]) :: Binds
    pattern $mIPBinds :: forall {r}. Binds -> ([IPBind] -> r) -> ((# #) -> r) -> r
    $bIPBinds :: [IPBind] -> Binds
    IPBinds a = H.IPBinds () (a :: [IPBind]) :: Binds

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE BDecls, IPBinds #-}
    #endif

    -- ** `H.IPBind`
    type IPBind = H.IPBind ()
    pattern $mIPBind :: forall {r}. IPBind -> (IPName -> Exp -> r) -> ((# #) -> r) -> r
    $bIPBind :: IPName -> Exp -> IPBind
    IPBind a b = H.IPBind () (a :: IPName) (b :: Exp) :: IPBind

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE IPBind #-}
    #endif

    -- ** `H.Match`
    type Match = H.Match ()
    pattern $mMatch :: forall {r}.
    Match
    -> (Name -> [Pat] -> Rhs -> Maybe Binds -> r) -> ((# #) -> r) -> r
    $bMatch :: Name -> [Pat] -> Rhs -> Maybe Binds -> Match
    Match a b c d = H.Match () (a :: Name) (b :: [Pat]) (c :: Rhs) (d :: (Maybe Binds)) :: Match
    pattern $mInfixMatch :: forall {r}.
    Match
    -> (Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> r)
    -> ((# #) -> r)
    -> r
    $bInfixMatch :: Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> Match
    InfixMatch a b c d e = H.InfixMatch () (a :: Pat) (b :: Name) (c :: [Pat]) (d :: Rhs) (e :: (Maybe Binds)) :: Match

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Match, InfixMatch #-}
    #endif

    -- ** `H.QualConDecl`
    type QualConDecl = H.QualConDecl ()
    pattern $mQualConDecl :: forall {r}.
    QualConDecl
    -> (Maybe [TyVarBind] -> Maybe Context -> ConDecl -> r)
    -> ((# #) -> r)
    -> r
    $bQualConDecl :: Maybe [TyVarBind] -> Maybe Context -> ConDecl -> QualConDecl
    QualConDecl a b c = H.QualConDecl () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: ConDecl) :: QualConDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE QualConDecl #-}
    #endif

    -- ** `H.ConDecl`
    type ConDecl = H.ConDecl ()
    pattern $mConDecl :: forall {r}. ConDecl -> (Name -> [Type] -> r) -> ((# #) -> r) -> r
    $bConDecl :: Name -> [Type] -> ConDecl
    ConDecl a b = H.ConDecl () (a :: Name) (b :: [Type]) :: ConDecl
    pattern $mInfixConDecl :: forall {r}.
    ConDecl -> (Type -> Name -> Type -> r) -> ((# #) -> r) -> r
    $bInfixConDecl :: Type -> Name -> Type -> ConDecl
    InfixConDecl a b c = H.InfixConDecl () (a :: Type) (b :: Name) (c :: Type) :: ConDecl
    pattern $mRecDecl :: forall {r}.
    ConDecl -> (Name -> [FieldDecl] -> r) -> ((# #) -> r) -> r
    $bRecDecl :: Name -> [FieldDecl] -> ConDecl
    RecDecl a b = H.RecDecl () (a :: Name) (b :: [FieldDecl]) :: ConDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ConDecl, InfixConDecl, RecDecl #-}
    #endif

    -- ** `H.FieldDecl`
    type FieldDecl = H.FieldDecl ()
    pattern $mFieldDecl :: forall {r}. FieldDecl -> ([Name] -> Type -> r) -> ((# #) -> r) -> r
    $bFieldDecl :: [Name] -> Type -> FieldDecl
    FieldDecl a b = H.FieldDecl () (a :: [Name]) (b :: Type) :: FieldDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE FieldDecl #-}
    #endif

    -- ** `H.GadtDecl`
    type GadtDecl = H.GadtDecl ()
    pattern $mGadtDecl :: forall {r}.
    GadtDecl
    -> (Name
        -> Maybe [TyVarBind]
        -> Maybe Context
        -> Maybe [FieldDecl]
        -> Type
        -> r)
    -> ((# #) -> r)
    -> r
    $bGadtDecl :: Name
    -> Maybe [TyVarBind]
    -> Maybe Context
    -> Maybe [FieldDecl]
    -> Type
    -> GadtDecl
    GadtDecl a b c d e = H.GadtDecl () (a :: Name) (b :: (Maybe [TyVarBind])) (c :: (Maybe Context)) (d :: (Maybe [FieldDecl])) (e :: Type) :: GadtDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE GadtDecl #-}
    #endif

    -- ** `H.ClassDecl`
    type ClassDecl = H.ClassDecl ()
    pattern $mClsDecl :: forall {r}. ClassDecl -> (Decl -> r) -> ((# #) -> r) -> r
    $bClsDecl :: Decl -> ClassDecl
    ClsDecl a = H.ClsDecl () (a :: Decl) :: ClassDecl
    pattern $mClsDataFam :: forall {r}.
    ClassDecl
    -> (Maybe Context -> DeclHead -> Maybe ResultSig -> r)
    -> ((# #) -> r)
    -> r
    $bClsDataFam :: Maybe Context -> DeclHead -> Maybe ResultSig -> ClassDecl
    ClsDataFam a b c = H.ClsDataFam () (a :: (Maybe Context)) (b :: DeclHead) (c :: (Maybe ResultSig)) :: ClassDecl
    pattern $mClsTyFam :: forall {r}.
    ClassDecl
    -> (DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> r)
    -> ((# #) -> r)
    -> r
    $bClsTyFam :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> ClassDecl
    ClsTyFam a b c = H.ClsTyFam () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) :: ClassDecl
    pattern $mClsTyDef :: forall {r}. ClassDecl -> (TypeEqn -> r) -> ((# #) -> r) -> r
    $bClsTyDef :: TypeEqn -> ClassDecl
    ClsTyDef a = H.ClsTyDef () (a :: TypeEqn) :: ClassDecl
    pattern $mClsDefSig :: forall {r}. ClassDecl -> (Name -> Type -> r) -> ((# #) -> r) -> r
    $bClsDefSig :: Name -> Type -> ClassDecl
    ClsDefSig a b = H.ClsDefSig () (a :: Name) (b :: Type) :: ClassDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ClsDecl, ClsDataFam, ClsTyFam, ClsTyDef, ClsDefSig #-}
    #endif

    -- ** `H.InstDecl`
    type InstDecl = H.InstDecl ()
    pattern $mInsDecl :: forall {r}. InstDecl -> (Decl -> r) -> ((# #) -> r) -> r
    $bInsDecl :: Decl -> InstDecl
    InsDecl a = H.InsDecl () (a :: Decl) :: InstDecl
    pattern $mInsType :: forall {r}. InstDecl -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bInsType :: Type -> Type -> InstDecl
    InsType a b = H.InsType () (a :: Type) (b :: Type) :: InstDecl
    pattern $mInsData :: forall {r}.
    InstDecl
    -> (DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> r)
    -> ((# #) -> r)
    -> r
    $bInsData :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> InstDecl
    InsData a b c d = H.InsData () (a :: DataOrNew) (b :: Type) (c :: [QualConDecl]) (d :: [Deriving]) :: InstDecl
    pattern $mInsGData :: forall {r}.
    InstDecl
    -> (DataOrNew
        -> Type -> Maybe Type -> [GadtDecl] -> [Deriving] -> r)
    -> ((# #) -> r)
    -> r
    $bInsGData :: DataOrNew
    -> Type -> Maybe Type -> [GadtDecl] -> [Deriving] -> InstDecl
    InsGData a b c d e = H.InsGData () (a :: DataOrNew) (b :: Type) (c :: (Maybe Kind)) (d :: [GadtDecl]) (e :: [Deriving]) :: InstDecl

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE InsDecl, InsType, InsData, InsGData #-}
    #endif

    -- ** `H.BangType`
    type BangType = H.BangType ()
    pattern $mBangedTy :: forall {r}. BangType -> ((# #) -> r) -> ((# #) -> r) -> r
    $bBangedTy :: BangType
    BangedTy = H.BangedTy () :: BangType
    pattern $mLazyTy :: forall {r}. BangType -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLazyTy :: BangType
    LazyTy = H.LazyTy () :: BangType
    pattern $mNoStrictAnnot :: forall {r}. BangType -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNoStrictAnnot :: BangType
    NoStrictAnnot = H.NoStrictAnnot () :: BangType

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE BangedTy, LazyTy, NoStrictAnnot #-}
    #endif

    -- ** `H.Unpackedness`
    type Unpackedness = H.Unpackedness ()
    pattern $mUnpack :: forall {r}. Unpackedness -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUnpack :: Unpackedness
    Unpack = H.Unpack () :: Unpackedness
    pattern $mNoUnpack :: forall {r}. Unpackedness -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNoUnpack :: Unpackedness
    NoUnpack = H.NoUnpack () :: Unpackedness
    pattern $mNoUnpackPragma :: forall {r}. Unpackedness -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNoUnpackPragma :: Unpackedness
    NoUnpackPragma = H.NoUnpackPragma () :: Unpackedness

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Unpack, NoUnpack, NoUnpackPragma #-}
    #endif

    -- ** `H.Rhs`
    type Rhs = H.Rhs ()
    pattern $mUnGuardedRhs :: forall {r}. Rhs -> (Exp -> r) -> ((# #) -> r) -> r
    $bUnGuardedRhs :: Exp -> Rhs
    UnGuardedRhs a = H.UnGuardedRhs () (a :: Exp) :: Rhs
    pattern $mGuardedRhss :: forall {r}. Rhs -> ([GuardedRhs] -> r) -> ((# #) -> r) -> r
    $bGuardedRhss :: [GuardedRhs] -> Rhs
    GuardedRhss a = H.GuardedRhss () (a :: [GuardedRhs]) :: Rhs

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE UnGuardedRhs, GuardedRhss #-}
    #endif

    -- ** `H.GuardedRhs`
    type GuardedRhs = H.GuardedRhs ()
    pattern $mGuardedRhs :: forall {r}. GuardedRhs -> ([Stmt] -> Exp -> r) -> ((# #) -> r) -> r
    $bGuardedRhs :: [Stmt] -> Exp -> GuardedRhs
    GuardedRhs a b = H.GuardedRhs () (a :: [Stmt]) (b :: Exp) :: GuardedRhs

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE GuardedRhs #-}
    #endif

    -- ** `H.Type`
    type Type = H.Type ()
    pattern $mTyForall :: forall {r}.
    Type
    -> (Maybe [TyVarBind] -> Maybe Context -> Type -> r)
    -> ((# #) -> r)
    -> r
    $bTyForall :: Maybe [TyVarBind] -> Maybe Context -> Type -> Type
    TyForall a b c = H.TyForall () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: Type) :: Type
    pattern $mTyStar :: forall {r}. Type -> ((# #) -> r) -> ((# #) -> r) -> r
    $bTyStar :: Type
    TyStar = H.TyStar () :: Type
    pattern $mTyFun :: forall {r}. Type -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bTyFun :: Type -> Type -> Type
    TyFun a b = H.TyFun () (a :: Type) (b :: Type) :: Type
    pattern $mTyTuple :: forall {r}. Type -> (Boxed -> [Type] -> r) -> ((# #) -> r) -> r
    $bTyTuple :: Boxed -> [Type] -> Type
    TyTuple a b = H.TyTuple () (a :: Boxed) (b :: [Type]) :: Type
    pattern $mTyUnboxedSum :: forall {r}. Type -> ([Type] -> r) -> ((# #) -> r) -> r
    $bTyUnboxedSum :: [Type] -> Type
    TyUnboxedSum a = H.TyUnboxedSum () (a :: [Type]) :: Type
    pattern $mTyList :: forall {r}. Type -> (Type -> r) -> ((# #) -> r) -> r
    $bTyList :: Type -> Type
    TyList a = H.TyList () (a :: Type) :: Type
    pattern $mTyParArray :: forall {r}. Type -> (Type -> r) -> ((# #) -> r) -> r
    $bTyParArray :: Type -> Type
    TyParArray a = H.TyParArray () (a :: Type) :: Type
    pattern $mTyApp :: forall {r}. Type -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bTyApp :: Type -> Type -> Type
    TyApp a b = H.TyApp () (a :: Type) (b :: Type) :: Type
    pattern $mTyVar :: forall {r}. Type -> (Name -> r) -> ((# #) -> r) -> r
    $bTyVar :: Name -> Type
    TyVar a = H.TyVar () (a :: Name) :: Type
    pattern $mTyCon :: forall {r}. Type -> (QName -> r) -> ((# #) -> r) -> r
    $bTyCon :: QName -> Type
    TyCon a = H.TyCon () (a :: QName) :: Type
    pattern $mTyParen :: forall {r}. Type -> (Type -> r) -> ((# #) -> r) -> r
    $bTyParen :: Type -> Type
    TyParen a = H.TyParen () (a :: Type) :: Type
    pattern $mTyInfix :: forall {r}.
    Type
    -> (Type -> MaybePromotedName -> Type -> r) -> ((# #) -> r) -> r
    $bTyInfix :: Type -> MaybePromotedName -> Type -> Type
    TyInfix a b c = H.TyInfix () (a :: Type) (b :: MaybePromotedName) (c :: Type) :: Type
    pattern $mTyKind :: forall {r}. Type -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bTyKind :: Type -> Type -> Type
    TyKind a b = H.TyKind () (a :: Type) (b :: Kind) :: Type
    pattern $mTyPromoted :: forall {r}. Type -> (Promoted -> r) -> ((# #) -> r) -> r
    $bTyPromoted :: Promoted -> Type
    TyPromoted a = H.TyPromoted () (a :: Promoted) :: Type
    pattern $mTyEquals :: forall {r}. Type -> (Type -> Type -> r) -> ((# #) -> r) -> r
    $bTyEquals :: Type -> Type -> Type
    TyEquals a b = H.TyEquals () (a :: Type) (b :: Type) :: Type
    pattern $mTySplice :: forall {r}. Type -> (Splice -> r) -> ((# #) -> r) -> r
    $bTySplice :: Splice -> Type
    TySplice a = H.TySplice () (a :: Splice) :: Type
    pattern $mTyBang :: forall {r}.
    Type
    -> (BangType -> Unpackedness -> Type -> r) -> ((# #) -> r) -> r
    $bTyBang :: BangType -> Unpackedness -> Type -> Type
    TyBang a b c = H.TyBang () (a :: BangType) (b :: Unpackedness) (c :: Type) :: Type
    pattern $mTyWildCard :: forall {r}. Type -> (Maybe Name -> r) -> ((# #) -> r) -> r
    $bTyWildCard :: Maybe Name -> Type
    TyWildCard a = H.TyWildCard () (a :: (Maybe Name)) :: Type
    pattern $mTyQuasiQuote :: forall {r}. Type -> (String -> String -> r) -> ((# #) -> r) -> r
    $bTyQuasiQuote :: String -> String -> Type
    TyQuasiQuote a b = H.TyQuasiQuote () (a :: String) (b :: String) :: Type

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE TyForall, TyStar, TyFun, TyTuple, TyUnboxedSum, TyList, TyParArray, TyApp,
                 TyVar, TyCon, TyParen, TyInfix, TyKind, TyPromoted, TyEquals, TySplice,
                 TyBang, TyWildCard, TyQuasiQuote #-}
    #endif

    -- ** `H.MaybePromotedName`
    type MaybePromotedName = H.MaybePromotedName ()
    pattern $mPromotedName :: forall {r}. MaybePromotedName -> (QName -> r) -> ((# #) -> r) -> r
    $bPromotedName :: QName -> MaybePromotedName
    PromotedName a = H.PromotedName () (a :: QName) :: MaybePromotedName
    pattern $mUnpromotedName :: forall {r}. MaybePromotedName -> (QName -> r) -> ((# #) -> r) -> r
    $bUnpromotedName :: QName -> MaybePromotedName
    UnpromotedName a = H.UnpromotedName () (a :: QName) :: MaybePromotedName

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE PromotedName, UnpromotedName #-}
    #endif

    -- ** `H.Promoted`
    type Promoted = H.Promoted ()
    pattern $mPromotedInteger :: forall {r}.
    Promoted -> (Integer -> String -> r) -> ((# #) -> r) -> r
    $bPromotedInteger :: Integer -> String -> Promoted
    PromotedInteger a b = H.PromotedInteger () (a :: Integer) (b :: String) :: Promoted
    pattern $mPromotedString :: forall {r}.
    Promoted -> (String -> String -> r) -> ((# #) -> r) -> r
    $bPromotedString :: String -> String -> Promoted
    PromotedString a b = H.PromotedString () (a :: String) (b :: String) :: Promoted
    pattern $mPromotedCon :: forall {r}. Promoted -> (Bool -> QName -> r) -> ((# #) -> r) -> r
    $bPromotedCon :: Bool -> QName -> Promoted
    PromotedCon a b = H.PromotedCon () (a :: Bool) (b :: QName) :: Promoted
    pattern $mPromotedList :: forall {r}. Promoted -> (Bool -> [Type] -> r) -> ((# #) -> r) -> r
    $bPromotedList :: Bool -> [Type] -> Promoted
    PromotedList a b = H.PromotedList () (a :: Bool) (b :: [Type]) :: Promoted
    pattern $mPromotedTuple :: forall {r}. Promoted -> ([Type] -> r) -> ((# #) -> r) -> r
    $bPromotedTuple :: [Type] -> Promoted
    PromotedTuple a = H.PromotedTuple () (a :: [Type]) :: Promoted
    pattern $mPromotedUnit :: forall {r}. Promoted -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPromotedUnit :: Promoted
    PromotedUnit = H.PromotedUnit () :: Promoted

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE PromotedInteger, PromotedString, PromotedCon, PromotedList, PromotedTuple,
                 PromotedUnit #-}
    #endif

    -- skipped: data Boxed

    -- ** `H.TyVarBind`
    type TyVarBind = H.TyVarBind ()
    pattern $mKindedVar :: forall {r}. TyVarBind -> (Name -> Type -> r) -> ((# #) -> r) -> r
    $bKindedVar :: Name -> Type -> TyVarBind
    KindedVar a b = H.KindedVar () (a :: Name) (b :: Kind) :: TyVarBind
    pattern $mUnkindedVar :: forall {r}. TyVarBind -> (Name -> r) -> ((# #) -> r) -> r
    $bUnkindedVar :: Name -> TyVarBind
    UnkindedVar a = H.UnkindedVar () (a :: Name) :: TyVarBind

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE KindedVar, UnkindedVar #-}
    #endif

    -- ** `H.Kind`

    -- | Note that `Kind` is an alias for `Type` since haskell-src-exts-1.21.
    type Kind = H.Kind ()

    -- ** `H.FunDep`
    type FunDep = H.FunDep ()
    pattern $mFunDep :: forall {r}. FunDep -> ([Name] -> [Name] -> r) -> ((# #) -> r) -> r
    $bFunDep :: [Name] -> [Name] -> FunDep
    FunDep a b = H.FunDep () (a :: [Name]) (b :: [Name]) :: FunDep

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE FunDep #-}
    #endif

    -- ** `H.Context`
    type Context = H.Context ()
    pattern $mCxSingle :: forall {r}. Context -> (Asst -> r) -> ((# #) -> r) -> r
    $bCxSingle :: Asst -> Context
    CxSingle a = H.CxSingle () (a :: Asst) :: Context
    pattern $mCxTuple :: forall {r}. Context -> ([Asst] -> r) -> ((# #) -> r) -> r
    $bCxTuple :: [Asst] -> Context
    CxTuple a = H.CxTuple () (a :: [Asst]) :: Context
    pattern $mCxEmpty :: forall {r}. Context -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCxEmpty :: Context
    CxEmpty = H.CxEmpty () :: Context

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE CxSingle, CxTuple, CxEmpty #-}
    #endif

    -- ** `H.Asst`
    type Asst = H.Asst ()
    pattern $mTypeA :: forall {r}. Asst -> (Type -> r) -> ((# #) -> r) -> r
    $bTypeA :: Type -> Asst
    TypeA a = H.TypeA () (a :: Type) :: Asst
    pattern $mIParam :: forall {r}. Asst -> (IPName -> Type -> r) -> ((# #) -> r) -> r
    $bIParam :: IPName -> Type -> Asst
    IParam a b = H.IParam () (a :: IPName) (b :: Type) :: Asst
    pattern $mParenA :: forall {r}. Asst -> (Asst -> r) -> ((# #) -> r) -> r
    $bParenA :: Asst -> Asst
    ParenA a = H.ParenA () (a :: Asst) :: Asst

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE TypeA, IParam, ParenA #-}
    #endif

    -- ** `H.Literal`
    type Literal = H.Literal ()

    pattern $mChar :: forall {r}. Literal -> (Char -> r) -> ((# #) -> r) -> r
    $bChar :: Char -> Literal
    Char a <- H.Char () (a :: Char) _ :: Literal
        where Char Char
    a = () -> Char -> String -> Literal
    forall l. l -> Char -> String -> Literal l
    H.Char () Char
    a [Char
    a]
    charL :: Char -> Literal
    charL :: Char -> Literal
    charL Char
    a = () -> Char -> String -> Literal
    forall l. l -> Char -> String -> Literal l
    H.Char () Char
    a [Char
    a]

    pattern $mString :: forall {r}. Literal -> (String -> r) -> ((# #) -> r) -> r
    $bString :: String -> Literal
    String a <- H.String () (a :: String) _ :: Literal
        where String String
    a = String -> Literal
    stringL String
    a
    stringL :: String -> Literal
    stringL :: String -> Literal
    stringL String
    a = () -> String -> String -> Literal
    forall l. l -> String -> String -> Literal l
    H.String () String
    a String
    a

    pattern $mInt :: forall {r}. Literal -> (Integer -> r) -> ((# #) -> r) -> r
    $bInt :: Integer -> Literal
    Int a <- H.Int () (a :: Integer) _ :: Literal
        where Int Integer
    a = Integer -> Literal
    intL Integer
    a
    intL :: Integer -> Literal
    intL :: Integer -> Literal
    intL Integer
    a = () -> Integer -> String -> Literal
    forall l. l -> Integer -> String -> Literal l
    H.Int () Integer
    a (Integer -> String
    forall a. Show a => a -> String
    show Integer
    a)

    pattern $mFrac :: forall {r}. Literal -> (Rational -> r) -> ((# #) -> r) -> r
    $bFrac :: Rational -> Literal
    Frac a <- H.Frac () (a :: Rational) _ :: Literal
        where Frac Rational
    a = Rational -> Literal
    fracL Rational
    a
    fracL :: Rational -> Literal
    fracL :: Rational -> Literal
    fracL Rational
    a = () -> Rational -> String -> Literal
    forall l. l -> Rational -> String -> Literal l
    H.Frac () Rational
    a (Rational -> String
    forall a. Show a => a -> String
    show Rational
    a)

    pattern $mPrimInt :: forall {r}. Literal -> (Integer -> r) -> ((# #) -> r) -> r
    $bPrimInt :: Integer -> Literal
    PrimInt a <- H.PrimInt () (a :: Integer) _ :: Literal
        where PrimInt Integer
    a = Integer -> Literal
    primIntL Integer
    a
    primIntL :: Integer -> Literal
    primIntL :: Integer -> Literal
    primIntL Integer
    a = () -> Integer -> String -> Literal
    forall l. l -> Integer -> String -> Literal l
    H.PrimInt () Integer
    a (Integer -> String
    forall a. Show a => a -> String
    show Integer
    a)

    pattern $mPrimWord :: forall {r}. Literal -> (Integer -> r) -> ((# #) -> r) -> r
    $bPrimWord :: Integer -> Literal
    PrimWord a <- H.PrimWord () (a :: Integer) _ :: Literal
        where PrimWord Integer
    a = Integer -> Literal
    primWordL Integer
    a
    primWordL :: Integer -> Literal
    primWordL :: Integer -> Literal
    primWordL Integer
    a = () -> Integer -> String -> Literal
    forall l. l -> Integer -> String -> Literal l
    H.PrimWord () Integer
    a (Integer -> String
    forall a. Show a => a -> String
    show Integer
    a)

    pattern $mPrimFloat :: forall {r}. Literal -> (Rational -> r) -> ((# #) -> r) -> r
    $bPrimFloat :: Rational -> Literal
    PrimFloat a <- H.PrimFloat () (a :: Rational) _ :: Literal
        where PrimFloat Rational
    a = Rational -> Literal
    primFloatL Rational
    a
    primFloatL :: Rational -> Literal
    primFloatL :: Rational -> Literal
    primFloatL Rational
    a = () -> Rational -> String -> Literal
    forall l. l -> Rational -> String -> Literal l
    H.PrimFloat () Rational
    a (Float -> String
    forall a. Show a => a -> String
    show (Rational -> Float
    forall a. Fractional a => Rational -> a
    fromRational Rational
    a :: Float))

    pattern $mPrimDouble :: forall {r}. Literal -> (Rational -> r) -> ((# #) -> r) -> r
    $bPrimDouble :: Rational -> Literal
    PrimDouble a <- H.PrimDouble () (a :: Rational) _ :: Literal
        where PrimDouble Rational
    a = Rational -> Literal
    primDoubleL Rational
    a
    primDoubleL :: Rational -> Literal
    primDoubleL :: Rational -> Literal
    primDoubleL Rational
    a = () -> Rational -> String -> Literal
    forall l. l -> Rational -> String -> Literal l
    H.PrimDouble () Rational
    a (Double -> String
    forall a. Show a => a -> String
    show (Rational -> Double
    forall a. Fractional a => Rational -> a
    fromRational Rational
    a :: Double))

    pattern $mPrimChar :: forall {r}. Literal -> (Char -> r) -> ((# #) -> r) -> r
    $bPrimChar :: Char -> Literal
    PrimChar a <- H.PrimChar () (a :: Char) _ :: Literal
        where PrimChar Char
    a = Char -> Literal
    primCharL Char
    a
    primCharL :: Char -> Literal
    primCharL :: Char -> Literal
    primCharL Char
    a = () -> Char -> String -> Literal
    forall l. l -> Char -> String -> Literal l
    H.PrimChar () Char
    a [Char
    a]

    pattern $mPrimString :: forall {r}. Literal -> (String -> r) -> ((# #) -> r) -> r
    $bPrimString :: String -> Literal
    PrimString a <- H.PrimString () (a :: String) _ :: Literal
        where PrimString String
    a = String -> Literal
    primStringL String
    a
    primStringL :: String -> Literal
    primStringL :: String -> Literal
    primStringL String
    a = () -> String -> String -> Literal
    forall l. l -> String -> String -> Literal l
    H.PrimString () String
    a String
    a

    #undef where

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Char, String, Int, Frac, PrimInt, PrimWord, PrimFloat, PrimDouble,
                 PrimChar, PrimString #-}
    #endif

    -- ** `H.Sign`
    type Sign = H.Sign ()
    pattern $mSignless :: forall {r}. Sign -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSignless :: Sign
    Signless = H.Signless () :: Sign
    pattern $mNegative :: forall {r}. Sign -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNegative :: Sign
    Negative = H.Negative () :: Sign

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Signless, Negative #-}
    #endif

    -- ** `H.Exp`
    type Exp = H.Exp ()
    pattern $mVar :: forall {r}. Exp -> (QName -> r) -> ((# #) -> r) -> r
    $bVar :: QName -> Exp
    Var a = H.Var () (a :: QName) :: Exp
    pattern $mOverloadedLabel :: forall {r}. Exp -> (String -> r) -> ((# #) -> r) -> r
    $bOverloadedLabel :: String -> Exp
    OverloadedLabel a = H.OverloadedLabel () (a :: String) :: Exp
    pattern $mIPVar :: forall {r}. Exp -> (IPName -> r) -> ((# #) -> r) -> r
    $bIPVar :: IPName -> Exp
    IPVar a = H.IPVar () (a :: IPName) :: Exp
    pattern $mCon :: forall {r}. Exp -> (QName -> r) -> ((# #) -> r) -> r
    $bCon :: QName -> Exp
    Con a = H.Con () (a :: QName) :: Exp
    pattern $mLit :: forall {r}. Exp -> (Literal -> r) -> ((# #) -> r) -> r
    $bLit :: Literal -> Exp
    Lit a = H.Lit () (a :: Literal) :: Exp
    pattern $mInfixApp :: forall {r}. Exp -> (Exp -> QOp -> Exp -> r) -> ((# #) -> r) -> r
    $bInfixApp :: Exp -> QOp -> Exp -> Exp
    InfixApp a b c = H.InfixApp () (a :: Exp) (b :: QOp) (c :: Exp) :: Exp
    pattern $mApp :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bApp :: Exp -> Exp -> Exp
    App a b = H.App () (a :: Exp) (b :: Exp) :: Exp
    pattern $mNegApp :: forall {r}. Exp -> (Exp -> r) -> ((# #) -> r) -> r
    $bNegApp :: Exp -> Exp
    NegApp a = H.NegApp () (a :: Exp) :: Exp
    pattern $mLambda :: forall {r}. Exp -> ([Pat] -> Exp -> r) -> ((# #) -> r) -> r
    $bLambda :: [Pat] -> Exp -> Exp
    Lambda a b = H.Lambda () (a :: [Pat]) (b :: Exp) :: Exp
    pattern $mLet :: forall {r}. Exp -> (Binds -> Exp -> r) -> ((# #) -> r) -> r
    $bLet :: Binds -> Exp -> Exp
    Let a b = H.Let () (a :: Binds) (b :: Exp) :: Exp
    pattern $mIf :: forall {r}. Exp -> (Exp -> Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bIf :: Exp -> Exp -> Exp -> Exp
    If a b c = H.If () (a :: Exp) (b :: Exp) (c :: Exp) :: Exp
    pattern $mMultiIf :: forall {r}. Exp -> ([GuardedRhs] -> r) -> ((# #) -> r) -> r
    $bMultiIf :: [GuardedRhs] -> Exp
    MultiIf a = H.MultiIf () (a :: [GuardedRhs]) :: Exp
    pattern $mCase :: forall {r}. Exp -> (Exp -> [Alt] -> r) -> ((# #) -> r) -> r
    $bCase :: Exp -> [Alt] -> Exp
    Case a b = H.Case () (a :: Exp) (b :: [Alt]) :: Exp
    pattern $mDo :: forall {r}. Exp -> ([Stmt] -> r) -> ((# #) -> r) -> r
    $bDo :: [Stmt] -> Exp
    Do a = H.Do () (a :: [Stmt]) :: Exp
    pattern $mMDo :: forall {r}. Exp -> ([Stmt] -> r) -> ((# #) -> r) -> r
    $bMDo :: [Stmt] -> Exp
    MDo a = H.MDo () (a :: [Stmt]) :: Exp
    pattern $mTuple :: forall {r}. Exp -> (Boxed -> [Exp] -> r) -> ((# #) -> r) -> r
    $bTuple :: Boxed -> [Exp] -> Exp
    Tuple a b = H.Tuple () (a :: Boxed) (b :: [Exp]) :: Exp
    pattern $mUnboxedSum :: forall {r}. Exp -> (Int -> Int -> Exp -> r) -> ((# #) -> r) -> r
    $bUnboxedSum :: Int -> Int -> Exp -> Exp
    UnboxedSum a b c = H.UnboxedSum () (a :: Int) (b :: Int) (c :: Exp) :: Exp
    pattern $mTupleSection :: forall {r}. Exp -> (Boxed -> [Maybe Exp] -> r) -> ((# #) -> r) -> r
    $bTupleSection :: Boxed -> [Maybe Exp] -> Exp
    TupleSection a b = H.TupleSection () (a :: Boxed) (b :: [Maybe Exp]) :: Exp
    pattern $mList :: forall {r}. Exp -> ([Exp] -> r) -> ((# #) -> r) -> r
    $bList :: [Exp] -> Exp
    List a = H.List () (a :: [Exp]) :: Exp
    pattern $mParArray :: forall {r}. Exp -> ([Exp] -> r) -> ((# #) -> r) -> r
    $bParArray :: [Exp] -> Exp
    ParArray a = H.ParArray () (a :: [Exp]) :: Exp
    pattern $mParen :: forall {r}. Exp -> (Exp -> r) -> ((# #) -> r) -> r
    $bParen :: Exp -> Exp
    Paren a = H.Paren () (a :: Exp) :: Exp
    pattern $mLeftSection :: forall {r}. Exp -> (Exp -> QOp -> r) -> ((# #) -> r) -> r
    $bLeftSection :: Exp -> QOp -> Exp
    LeftSection a b = H.LeftSection () (a :: Exp) (b :: QOp) :: Exp
    pattern $mRightSection :: forall {r}. Exp -> (QOp -> Exp -> r) -> ((# #) -> r) -> r
    $bRightSection :: QOp -> Exp -> Exp
    RightSection a b = H.RightSection () (a :: QOp) (b :: Exp) :: Exp
    pattern $mRecConstr :: forall {r}.
    Exp -> (QName -> [FieldUpdate] -> r) -> ((# #) -> r) -> r
    $bRecConstr :: QName -> [FieldUpdate] -> Exp
    RecConstr a b = H.RecConstr () (a :: QName) (b :: [FieldUpdate]) :: Exp
    pattern $mRecUpdate :: forall {r}. Exp -> (Exp -> [FieldUpdate] -> r) -> ((# #) -> r) -> r
    $bRecUpdate :: Exp -> [FieldUpdate] -> Exp
    RecUpdate a b = H.RecUpdate () (a :: Exp) (b :: [FieldUpdate]) :: Exp
    pattern $mEnumFrom :: forall {r}. Exp -> (Exp -> r) -> ((# #) -> r) -> r
    $bEnumFrom :: Exp -> Exp
    EnumFrom a = H.EnumFrom () (a :: Exp) :: Exp
    pattern $mEnumFromTo :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bEnumFromTo :: Exp -> Exp -> Exp
    EnumFromTo a b = H.EnumFromTo () (a :: Exp) (b :: Exp) :: Exp
    pattern $mEnumFromThen :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bEnumFromThen :: Exp -> Exp -> Exp
    EnumFromThen a b = H.EnumFromThen () (a :: Exp) (b :: Exp) :: Exp
    pattern $mEnumFromThenTo :: forall {r}. Exp -> (Exp -> Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bEnumFromThenTo :: Exp -> Exp -> Exp -> Exp
    EnumFromThenTo a b c = H.EnumFromThenTo () (a :: Exp) (b :: Exp) (c :: Exp) :: Exp
    pattern $mParArrayFromTo :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bParArrayFromTo :: Exp -> Exp -> Exp
    ParArrayFromTo a b = H.ParArrayFromTo () (a :: Exp) (b :: Exp) :: Exp
    pattern $mParArrayFromThenTo :: forall {r}. Exp -> (Exp -> Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bParArrayFromThenTo :: Exp -> Exp -> Exp -> Exp
    ParArrayFromThenTo a b c = H.ParArrayFromThenTo () (a :: Exp) (b :: Exp) (c :: Exp) :: Exp
    pattern $mListComp :: forall {r}. Exp -> (Exp -> [QualStmt] -> r) -> ((# #) -> r) -> r
    $bListComp :: Exp -> [QualStmt] -> Exp
    ListComp a b = H.ListComp () (a :: Exp) (b :: [QualStmt]) :: Exp
    pattern $mParComp :: forall {r}. Exp -> (Exp -> [[QualStmt]] -> r) -> ((# #) -> r) -> r
    $bParComp :: Exp -> [[QualStmt]] -> Exp
    ParComp a b = H.ParComp () (a :: Exp) (b :: [[QualStmt]]) :: Exp
    pattern $mParArrayComp :: forall {r}. Exp -> (Exp -> [[QualStmt]] -> r) -> ((# #) -> r) -> r
    $bParArrayComp :: Exp -> [[QualStmt]] -> Exp
    ParArrayComp a b = H.ParArrayComp () (a :: Exp) (b :: [[QualStmt]]) :: Exp
    pattern $mExpTypeSig :: forall {r}. Exp -> (Exp -> Type -> r) -> ((# #) -> r) -> r
    $bExpTypeSig :: Exp -> Type -> Exp
    ExpTypeSig a b = H.ExpTypeSig () (a :: Exp) (b :: Type) :: Exp
    pattern $mVarQuote :: forall {r}. Exp -> (QName -> r) -> ((# #) -> r) -> r
    $bVarQuote :: QName -> Exp
    VarQuote a = H.VarQuote () (a :: QName) :: Exp
    pattern $mTypQuote :: forall {r}. Exp -> (QName -> r) -> ((# #) -> r) -> r
    $bTypQuote :: QName -> Exp
    TypQuote a = H.TypQuote () (a :: QName) :: Exp
    pattern $mBracketExp :: forall {r}. Exp -> (Bracket -> r) -> ((# #) -> r) -> r
    $bBracketExp :: Bracket -> Exp
    BracketExp a = H.BracketExp () (a :: Bracket) :: Exp
    pattern $mSpliceExp :: forall {r}. Exp -> (Splice -> r) -> ((# #) -> r) -> r
    $bSpliceExp :: Splice -> Exp
    SpliceExp a = H.SpliceExp () (a :: Splice) :: Exp
    pattern $mQuasiQuote :: forall {r}. Exp -> (String -> String -> r) -> ((# #) -> r) -> r
    $bQuasiQuote :: String -> String -> Exp
    QuasiQuote a b = H.QuasiQuote () (a :: String) (b :: String) :: Exp
    pattern $mTypeApp :: forall {r}. Exp -> (Type -> r) -> ((# #) -> r) -> r
    $bTypeApp :: Type -> Exp
    TypeApp a = H.TypeApp () (a :: Type) :: Exp
    pattern $mXTag :: forall {r}.
    Exp
    -> (XName -> [XAttr] -> Maybe Exp -> [Exp] -> r)
    -> ((# #) -> r)
    -> r
    $bXTag :: XName -> [XAttr] -> Maybe Exp -> [Exp] -> Exp
    XTag a b c d = H.XTag () (a :: XName) (b :: [XAttr]) (c :: (Maybe Exp)) (d :: [Exp]) :: Exp
    pattern $mXETag :: forall {r}.
    Exp -> (XName -> [XAttr] -> Maybe Exp -> r) -> ((# #) -> r) -> r
    $bXETag :: XName -> [XAttr] -> Maybe Exp -> Exp
    XETag a b c = H.XETag () (a :: XName) (b :: [XAttr]) (c :: (Maybe Exp)) :: Exp
    pattern $mXPcdata :: forall {r}. Exp -> (String -> r) -> ((# #) -> r) -> r
    $bXPcdata :: String -> Exp
    XPcdata a = H.XPcdata () (a :: String) :: Exp
    pattern $mXExpTag :: forall {r}. Exp -> (Exp -> r) -> ((# #) -> r) -> r
    $bXExpTag :: Exp -> Exp
    XExpTag a = H.XExpTag () (a :: Exp) :: Exp
    pattern $mXChildTag :: forall {r}. Exp -> ([Exp] -> r) -> ((# #) -> r) -> r
    $bXChildTag :: [Exp] -> Exp
    XChildTag a = H.XChildTag () (a :: [Exp]) :: Exp
    pattern $mCorePragma :: forall {r}. Exp -> (String -> Exp -> r) -> ((# #) -> r) -> r
    $bCorePragma :: String -> Exp -> Exp
    CorePragma a b = H.CorePragma () (a :: String) (b :: Exp) :: Exp
    pattern $mSCCPragma :: forall {r}. Exp -> (String -> Exp -> r) -> ((# #) -> r) -> r
    $bSCCPragma :: String -> Exp -> Exp
    SCCPragma a b = H.SCCPragma () (a :: String) (b :: Exp) :: Exp
    pattern $mGenPragma :: forall {r}.
    Exp
    -> (String -> (Int, Int) -> (Int, Int) -> Exp -> r)
    -> ((# #) -> r)
    -> r
    $bGenPragma :: String -> (Int, Int) -> (Int, Int) -> Exp -> Exp
    GenPragma a b c d = H.GenPragma () (a :: String) (b :: (Int, Int)) (c :: (Int, Int)) (d :: Exp) :: Exp
    pattern $mProc :: forall {r}. Exp -> (Pat -> Exp -> r) -> ((# #) -> r) -> r
    $bProc :: Pat -> Exp -> Exp
    Proc a b = H.Proc () (a :: Pat) (b :: Exp) :: Exp
    pattern $mLeftArrApp :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bLeftArrApp :: Exp -> Exp -> Exp
    LeftArrApp a b = H.LeftArrApp () (a :: Exp) (b :: Exp) :: Exp
    pattern $mRightArrApp :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bRightArrApp :: Exp -> Exp -> Exp
    RightArrApp a b = H.RightArrApp () (a :: Exp) (b :: Exp) :: Exp
    pattern $mLeftArrHighApp :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bLeftArrHighApp :: Exp -> Exp -> Exp
    LeftArrHighApp a b = H.LeftArrHighApp () (a :: Exp) (b :: Exp) :: Exp
    pattern $mRightArrHighApp :: forall {r}. Exp -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bRightArrHighApp :: Exp -> Exp -> Exp
    RightArrHighApp a b = H.RightArrHighApp () (a :: Exp) (b :: Exp) :: Exp
    pattern $mArrOp :: forall {r}. Exp -> (Exp -> r) -> ((# #) -> r) -> r
    $bArrOp :: Exp -> Exp
    ArrOp a = H.ArrOp () (a :: Exp) :: Exp
    pattern $mLCase :: forall {r}. Exp -> ([Alt] -> r) -> ((# #) -> r) -> r
    $bLCase :: [Alt] -> Exp
    LCase a = H.LCase () (a :: [Alt]) :: Exp

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Var, OverloadedLabel, IPVar, Con, Lit, InfixApp, App, NegApp, Lambda, Let,
                 If, MultiIf, Case, Do, MDo, Tuple, UnboxedSum, TupleSection, List,
                 ParArray, Paren, LeftSection, RightSection, RecConstr, RecUpdate,
                 EnumFrom, EnumFromTo, EnumFromThen, EnumFromThenTo, ParArrayFromTo,
                 ParArrayFromThenTo, ListComp, ParComp, ParArrayComp, ExpTypeSig, VarQuote,
                 TypQuote, BracketExp, SpliceExp, QuasiQuote, TypeApp, XTag, XETag,
                 XPcdata, XExpTag, XChildTag, CorePragma, SCCPragma, GenPragma, Proc,
                 LeftArrApp, RightArrApp, LeftArrHighApp, RightArrHighApp, ArrOp, LCase #-}
    #endif

    -- ** `H.XName`
    type XName = H.XName ()
    pattern $mXName :: forall {r}. XName -> (String -> r) -> ((# #) -> r) -> r
    $bXName :: String -> XName
    XName a = H.XName () (a :: String) :: XName
    pattern $mXDomName :: forall {r}. XName -> (String -> String -> r) -> ((# #) -> r) -> r
    $bXDomName :: String -> String -> XName
    XDomName a b = H.XDomName () (a :: String) (b :: String) :: XName

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE XName, XDomName #-}
    #endif

    -- ** `H.XAttr`
    type XAttr = H.XAttr ()
    pattern $mXAttr :: forall {r}. XAttr -> (XName -> Exp -> r) -> ((# #) -> r) -> r
    $bXAttr :: XName -> Exp -> XAttr
    XAttr a b = H.XAttr () (a :: XName) (b :: Exp) :: XAttr

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE XAttr #-}
    #endif

    -- ** `H.Bracket`
    type Bracket = H.Bracket ()
    pattern $mExpBracket :: forall {r}. Bracket -> (Exp -> r) -> ((# #) -> r) -> r
    $bExpBracket :: Exp -> Bracket
    ExpBracket a = H.ExpBracket () (a :: Exp) :: Bracket
    pattern $mTExpBracket :: forall {r}. Bracket -> (Exp -> r) -> ((# #) -> r) -> r
    $bTExpBracket :: Exp -> Bracket
    TExpBracket a = H.TExpBracket () (a :: Exp) :: Bracket
    pattern $mPatBracket :: forall {r}. Bracket -> (Pat -> r) -> ((# #) -> r) -> r
    $bPatBracket :: Pat -> Bracket
    PatBracket a = H.PatBracket () (a :: Pat) :: Bracket
    pattern $mTypeBracket :: forall {r}. Bracket -> (Type -> r) -> ((# #) -> r) -> r
    $bTypeBracket :: Type -> Bracket
    TypeBracket a = H.TypeBracket () (a :: Type) :: Bracket
    pattern $mDeclBracket :: forall {r}. Bracket -> ([Decl] -> r) -> ((# #) -> r) -> r
    $bDeclBracket :: [Decl] -> Bracket
    DeclBracket a = H.DeclBracket () (a :: [Decl]) :: Bracket

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ExpBracket, TExpBracket, PatBracket, TypeBracket, DeclBracket #-}
    #endif

    -- ** `H.Splice`
    type Splice = H.Splice ()
    pattern $mIdSplice :: forall {r}. Splice -> (String -> r) -> ((# #) -> r) -> r
    $bIdSplice :: String -> Splice
    IdSplice a = H.IdSplice () (a :: String) :: Splice
    pattern $mTIdSplice :: forall {r}. Splice -> (String -> r) -> ((# #) -> r) -> r
    $bTIdSplice :: String -> Splice
    TIdSplice a = H.TIdSplice () (a :: String) :: Splice
    pattern $mParenSplice :: forall {r}. Splice -> (Exp -> r) -> ((# #) -> r) -> r
    $bParenSplice :: Exp -> Splice
    ParenSplice a = H.ParenSplice () (a :: Exp) :: Splice
    pattern $mTParenSplice :: forall {r}. Splice -> (Exp -> r) -> ((# #) -> r) -> r
    $bTParenSplice :: Exp -> Splice
    TParenSplice a = H.TParenSplice () (a :: Exp) :: Splice

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE IdSplice, TIdSplice, ParenSplice, TParenSplice #-}
    #endif

    -- ** `H.Safety`
    type Safety = H.Safety ()
    pattern $mPlayRisky :: forall {r}. Safety -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPlayRisky :: Safety
    PlayRisky = H.PlayRisky () :: Safety
    pattern $mPlaySafe :: forall {r}. Safety -> (Bool -> r) -> ((# #) -> r) -> r
    $bPlaySafe :: Bool -> Safety
    PlaySafe a = H.PlaySafe () (a :: Bool) :: Safety
    pattern $mPlayInterruptible :: forall {r}. Safety -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPlayInterruptible :: Safety
    PlayInterruptible = H.PlayInterruptible () :: Safety

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE PlayRisky, PlaySafe, PlayInterruptible #-}
    #endif

    -- ** `H.CallConv`
    type CallConv = H.CallConv ()
    pattern $mStdCall :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bStdCall :: CallConv
    StdCall = H.StdCall () :: CallConv
    pattern $mCCall :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCCall :: CallConv
    CCall = H.CCall () :: CallConv
    pattern $mCPlusPlus :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCPlusPlus :: CallConv
    CPlusPlus = H.CPlusPlus () :: CallConv
    pattern $mDotNet :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDotNet :: CallConv
    DotNet = H.DotNet () :: CallConv
    pattern $mJvm :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bJvm :: CallConv
    Jvm = H.Jvm () :: CallConv
    pattern $mJs :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bJs :: CallConv
    Js = H.Js () :: CallConv
    pattern $mJavaScript :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bJavaScript :: CallConv
    JavaScript = H.JavaScript () :: CallConv
    pattern $mCApi :: forall {r}. CallConv -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCApi :: CallConv
    CApi = H.CApi () :: CallConv

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE StdCall, CCall, CPlusPlus, DotNet, Jvm, Js, JavaScript, CApi #-}
    #endif

    -- ** `H.ModulePragma`
    type ModulePragma = H.ModulePragma ()
    pattern $mLanguagePragma :: forall {r}. ModulePragma -> ([Name] -> r) -> ((# #) -> r) -> r
    $bLanguagePragma :: [Name] -> ModulePragma
    LanguagePragma a = H.LanguagePragma () (a :: [Name]) :: ModulePragma
    pattern $mOptionsPragma :: forall {r}.
    ModulePragma -> (Maybe Tool -> String -> r) -> ((# #) -> r) -> r
    $bOptionsPragma :: Maybe Tool -> String -> ModulePragma
    OptionsPragma a b = H.OptionsPragma () (a :: (Maybe Tool)) (b :: String) :: ModulePragma
    pattern $mAnnModulePragma :: forall {r}. ModulePragma -> (Annotation -> r) -> ((# #) -> r) -> r
    $bAnnModulePragma :: Annotation -> ModulePragma
    AnnModulePragma a = H.AnnModulePragma () (a :: Annotation) :: ModulePragma

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE LanguagePragma, OptionsPragma, AnnModulePragma #-}
    #endif

    -- skipped: data Tool

    -- ** `H.Overlap`
    type Overlap = H.Overlap ()
    pattern $mNoOverlap :: forall {r}. Overlap -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNoOverlap :: Overlap
    NoOverlap = H.NoOverlap () :: Overlap
    pattern $mOverlap :: forall {r}. Overlap -> ((# #) -> r) -> ((# #) -> r) -> r
    $bOverlap :: Overlap
    Overlap = H.Overlap () :: Overlap
    pattern $mOverlapping :: forall {r}. Overlap -> ((# #) -> r) -> ((# #) -> r) -> r
    $bOverlapping :: Overlap
    Overlapping = H.Overlapping () :: Overlap
    pattern $mOverlaps :: forall {r}. Overlap -> ((# #) -> r) -> ((# #) -> r) -> r
    $bOverlaps :: Overlap
    Overlaps = H.Overlaps () :: Overlap
    pattern $mOverlappable :: forall {r}. Overlap -> ((# #) -> r) -> ((# #) -> r) -> r
    $bOverlappable :: Overlap
    Overlappable = H.Overlappable () :: Overlap
    pattern $mIncoherent :: forall {r}. Overlap -> ((# #) -> r) -> ((# #) -> r) -> r
    $bIncoherent :: Overlap
    Incoherent = H.Incoherent () :: Overlap

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE NoOverlap, Overlap, Overlapping, Overlaps, Overlappable, Incoherent #-}
    #endif

    -- ** `H.Activation`
    type Activation = H.Activation ()
    pattern $mActiveFrom :: forall {r}. Activation -> (Int -> r) -> ((# #) -> r) -> r
    $bActiveFrom :: Int -> Activation
    ActiveFrom a = H.ActiveFrom () (a :: Int) :: Activation
    pattern $mActiveUntil :: forall {r}. Activation -> (Int -> r) -> ((# #) -> r) -> r
    $bActiveUntil :: Int -> Activation
    ActiveUntil a = H.ActiveUntil () (a :: Int) :: Activation

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE ActiveFrom, ActiveUntil #-}
    #endif

    -- ** `H.Rule`
    type Rule = H.Rule ()
    pattern $mRule :: forall {r}.
    Rule
    -> (String
        -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> r)
    -> ((# #) -> r)
    -> r
    $bRule :: String -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> Rule
    Rule a b c d e = H.Rule () (a :: String) (b :: (Maybe Activation)) (c :: (Maybe [RuleVar])) (d :: Exp) (e :: Exp) :: Rule

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Rule #-}
    #endif

    -- ** `H.RuleVar`
    type RuleVar = H.RuleVar ()
    pattern $mRuleVar :: forall {r}. RuleVar -> (Name -> r) -> ((# #) -> r) -> r
    $bRuleVar :: Name -> RuleVar
    RuleVar a = H.RuleVar () (a :: Name) :: RuleVar
    pattern $mTypedRuleVar :: forall {r}. RuleVar -> (Name -> Type -> r) -> ((# #) -> r) -> r
    $bTypedRuleVar :: Name -> Type -> RuleVar
    TypedRuleVar a b = H.TypedRuleVar () (a :: Name) (b :: Type) :: RuleVar

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE RuleVar, TypedRuleVar #-}
    #endif

    -- ** `H.WarningText`
    type WarningText = H.WarningText ()
    pattern $mDeprText :: forall {r}. WarningText -> (String -> r) -> ((# #) -> r) -> r
    $bDeprText :: String -> WarningText
    DeprText a = H.DeprText () (a :: String) :: WarningText
    pattern $mWarnText :: forall {r}. WarningText -> (String -> r) -> ((# #) -> r) -> r
    $bWarnText :: String -> WarningText
    WarnText a = H.WarnText () (a :: String) :: WarningText

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE DeprText, WarnText #-}
    #endif

    -- ** `H.Pat`
    type Pat = H.Pat ()
    pattern $mPVar :: forall {r}. Pat -> (Name -> r) -> ((# #) -> r) -> r
    $bPVar :: Name -> Pat
    PVar a = H.PVar () (a :: Name) :: Pat
    pattern $mPLit :: forall {r}. Pat -> (Sign -> Literal -> r) -> ((# #) -> r) -> r
    $bPLit :: Sign -> Literal -> Pat
    PLit a b = H.PLit () (a :: Sign) (b :: Literal) :: Pat
    pattern $mPNPlusK :: forall {r}. Pat -> (Name -> Integer -> r) -> ((# #) -> r) -> r
    $bPNPlusK :: Name -> Integer -> Pat
    PNPlusK a b = H.PNPlusK () (a :: Name) (b :: Integer) :: Pat
    pattern $mPInfixApp :: forall {r}. Pat -> (Pat -> QName -> Pat -> r) -> ((# #) -> r) -> r
    $bPInfixApp :: Pat -> QName -> Pat -> Pat
    PInfixApp a b c = H.PInfixApp () (a :: Pat) (b :: QName) (c :: Pat) :: Pat
    pattern $mPApp :: forall {r}. Pat -> (QName -> [Pat] -> r) -> ((# #) -> r) -> r
    $bPApp :: QName -> [Pat] -> Pat
    PApp a b = H.PApp () (a :: QName) (b :: [Pat]) :: Pat
    pattern $mPTuple :: forall {r}. Pat -> (Boxed -> [Pat] -> r) -> ((# #) -> r) -> r
    $bPTuple :: Boxed -> [Pat] -> Pat
    PTuple a b = H.PTuple () (a :: Boxed) (b :: [Pat]) :: Pat
    pattern $mPUnboxedSum :: forall {r}. Pat -> (Int -> Int -> Pat -> r) -> ((# #) -> r) -> r
    $bPUnboxedSum :: Int -> Int -> Pat -> Pat
    PUnboxedSum a b c = H.PUnboxedSum () (a :: Int) (b :: Int) (c :: Pat) :: Pat
    pattern $mPList :: forall {r}. Pat -> ([Pat] -> r) -> ((# #) -> r) -> r
    $bPList :: [Pat] -> Pat
    PList a = H.PList () (a :: [Pat]) :: Pat
    pattern $mPParen :: forall {r}. Pat -> (Pat -> r) -> ((# #) -> r) -> r
    $bPParen :: Pat -> Pat
    PParen a = H.PParen () (a :: Pat) :: Pat
    pattern $mPRec :: forall {r}. Pat -> (QName -> [PatField] -> r) -> ((# #) -> r) -> r
    $bPRec :: QName -> [PatField] -> Pat
    PRec a b = H.PRec () (a :: QName) (b :: [PatField]) :: Pat
    pattern $mPAsPat :: forall {r}. Pat -> (Name -> Pat -> r) -> ((# #) -> r) -> r
    $bPAsPat :: Name -> Pat -> Pat
    PAsPat a b = H.PAsPat () (a :: Name) (b :: Pat) :: Pat
    pattern $mPWildCard :: forall {r}. Pat -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPWildCard :: Pat
    PWildCard = H.PWildCard () :: Pat
    pattern $mPIrrPat :: forall {r}. Pat -> (Pat -> r) -> ((# #) -> r) -> r
    $bPIrrPat :: Pat -> Pat
    PIrrPat a = H.PIrrPat () (a :: Pat) :: Pat
    pattern $mPatTypeSig :: forall {r}. Pat -> (Pat -> Type -> r) -> ((# #) -> r) -> r
    $bPatTypeSig :: Pat -> Type -> Pat
    PatTypeSig a b = H.PatTypeSig () (a :: Pat) (b :: Type) :: Pat
    pattern $mPViewPat :: forall {r}. Pat -> (Exp -> Pat -> r) -> ((# #) -> r) -> r
    $bPViewPat :: Exp -> Pat -> Pat
    PViewPat a b = H.PViewPat () (a :: Exp) (b :: Pat) :: Pat
    pattern $mPRPat :: forall {r}. Pat -> ([RPat] -> r) -> ((# #) -> r) -> r
    $bPRPat :: [RPat] -> Pat
    PRPat a = H.PRPat () (a :: [RPat]) :: Pat
    pattern $mPXTag :: forall {r}.
    Pat
    -> (XName -> [PXAttr] -> Maybe Pat -> [Pat] -> r)
    -> ((# #) -> r)
    -> r
    $bPXTag :: XName -> [PXAttr] -> Maybe Pat -> [Pat] -> Pat
    PXTag a b c d = H.PXTag () (a :: XName) (b :: [PXAttr]) (c :: (Maybe Pat)) (d :: [Pat]) :: Pat
    pattern $mPXETag :: forall {r}.
    Pat -> (XName -> [PXAttr] -> Maybe Pat -> r) -> ((# #) -> r) -> r
    $bPXETag :: XName -> [PXAttr] -> Maybe Pat -> Pat
    PXETag a b c = H.PXETag () (a :: XName) (b :: [PXAttr]) (c :: (Maybe Pat)) :: Pat
    pattern $mPXPcdata :: forall {r}. Pat -> (String -> r) -> ((# #) -> r) -> r
    $bPXPcdata :: String -> Pat
    PXPcdata a = H.PXPcdata () (a :: String) :: Pat
    pattern $mPXPatTag :: forall {r}. Pat -> (Pat -> r) -> ((# #) -> r) -> r
    $bPXPatTag :: Pat -> Pat
    PXPatTag a = H.PXPatTag () (a :: Pat) :: Pat
    pattern $mPXRPats :: forall {r}. Pat -> ([RPat] -> r) -> ((# #) -> r) -> r
    $bPXRPats :: [RPat] -> Pat
    PXRPats a = H.PXRPats () (a :: [RPat]) :: Pat
    pattern $mPSplice :: forall {r}. Pat -> (Splice -> r) -> ((# #) -> r) -> r
    $bPSplice :: Splice -> Pat
    PSplice a = H.PSplice () (a :: Splice) :: Pat
    pattern $mPQuasiQuote :: forall {r}. Pat -> (String -> String -> r) -> ((# #) -> r) -> r
    $bPQuasiQuote :: String -> String -> Pat
    PQuasiQuote a b = H.PQuasiQuote () (a :: String) (b :: String) :: Pat
    pattern $mPBangPat :: forall {r}. Pat -> (Pat -> r) -> ((# #) -> r) -> r
    $bPBangPat :: Pat -> Pat
    PBangPat a = H.PBangPat () (a :: Pat) :: Pat

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE PVar, PLit, PNPlusK, PInfixApp, PApp, PTuple, PUnboxedSum, PList, PParen,
                 PRec, PAsPat, PWildCard, PIrrPat, PatTypeSig, PViewPat, PRPat, PXTag,
                 PXETag, PXPcdata, PXPatTag, PXRPats, PSplice, PQuasiQuote, PBangPat #-}
    #endif

    -- ** `H.PXAttr`
    type PXAttr = H.PXAttr ()
    pattern $mPXAttr :: forall {r}. PXAttr -> (XName -> Pat -> r) -> ((# #) -> r) -> r
    $bPXAttr :: XName -> Pat -> PXAttr
    PXAttr a b = H.PXAttr () (a :: XName) (b :: Pat) :: PXAttr

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE PXAttr #-}
    #endif

    -- ** `H.RPatOp`
    type RPatOp = H.RPatOp ()
    pattern $mRPStar :: forall {r}. RPatOp -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRPStar :: RPatOp
    RPStar = H.RPStar () :: RPatOp
    pattern $mRPStarG :: forall {r}. RPatOp -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRPStarG :: RPatOp
    RPStarG = H.RPStarG () :: RPatOp
    pattern $mRPPlus :: forall {r}. RPatOp -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRPPlus :: RPatOp
    RPPlus = H.RPPlus () :: RPatOp
    pattern $mRPPlusG :: forall {r}. RPatOp -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRPPlusG :: RPatOp
    RPPlusG = H.RPPlusG () :: RPatOp
    pattern $mRPOpt :: forall {r}. RPatOp -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRPOpt :: RPatOp
    RPOpt = H.RPOpt () :: RPatOp
    pattern $mRPOptG :: forall {r}. RPatOp -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRPOptG :: RPatOp
    RPOptG = H.RPOptG () :: RPatOp

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE RPStar, RPStarG, RPPlus, RPPlusG, RPOpt, RPOptG #-}
    #endif

    -- ** `H.RPat`
    type RPat = H.RPat ()
    pattern $mRPOp :: forall {r}. RPat -> (RPat -> RPatOp -> r) -> ((# #) -> r) -> r
    $bRPOp :: RPat -> RPatOp -> RPat
    RPOp a b = H.RPOp () (a :: RPat) (b :: RPatOp) :: RPat
    pattern $mRPEither :: forall {r}. RPat -> (RPat -> RPat -> r) -> ((# #) -> r) -> r
    $bRPEither :: RPat -> RPat -> RPat
    RPEither a b = H.RPEither () (a :: RPat) (b :: RPat) :: RPat
    pattern $mRPSeq :: forall {r}. RPat -> ([RPat] -> r) -> ((# #) -> r) -> r
    $bRPSeq :: [RPat] -> RPat
    RPSeq a = H.RPSeq () (a :: [RPat]) :: RPat
    pattern $mRPGuard :: forall {r}. RPat -> (Pat -> [Stmt] -> r) -> ((# #) -> r) -> r
    $bRPGuard :: Pat -> [Stmt] -> RPat
    RPGuard a b = H.RPGuard () (a :: Pat) (b :: [Stmt]) :: RPat
    pattern $mRPCAs :: forall {r}. RPat -> (Name -> RPat -> r) -> ((# #) -> r) -> r
    $bRPCAs :: Name -> RPat -> RPat
    RPCAs a b = H.RPCAs () (a :: Name) (b :: RPat) :: RPat
    pattern $mRPAs :: forall {r}. RPat -> (Name -> RPat -> r) -> ((# #) -> r) -> r
    $bRPAs :: Name -> RPat -> RPat
    RPAs a b = H.RPAs () (a :: Name) (b :: RPat) :: RPat
    pattern $mRPParen :: forall {r}. RPat -> (RPat -> r) -> ((# #) -> r) -> r
    $bRPParen :: RPat -> RPat
    RPParen a = H.RPParen () (a :: RPat) :: RPat
    pattern $mRPPat :: forall {r}. RPat -> (Pat -> r) -> ((# #) -> r) -> r
    $bRPPat :: Pat -> RPat
    RPPat a = H.RPPat () (a :: Pat) :: RPat

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE RPOp, RPEither, RPSeq, RPGuard, RPCAs, RPAs, RPParen, RPPat #-}
    #endif

    -- ** `H.PatField`
    type PatField = H.PatField ()
    pattern $mPFieldPat :: forall {r}. PatField -> (QName -> Pat -> r) -> ((# #) -> r) -> r
    $bPFieldPat :: QName -> Pat -> PatField
    PFieldPat a b = H.PFieldPat () (a :: QName) (b :: Pat) :: PatField
    pattern $mPFieldPun :: forall {r}. PatField -> (QName -> r) -> ((# #) -> r) -> r
    $bPFieldPun :: QName -> PatField
    PFieldPun a = H.PFieldPun () (a :: QName) :: PatField
    pattern $mPFieldWildcard :: forall {r}. PatField -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPFieldWildcard :: PatField
    PFieldWildcard = H.PFieldWildcard () :: PatField

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE PFieldPat, PFieldPun, PFieldWildcard #-}
    #endif

    -- ** `H.Stmt`
    type Stmt = H.Stmt ()
    pattern $mGenerator :: forall {r}. Stmt -> (Pat -> Exp -> r) -> ((# #) -> r) -> r
    $bGenerator :: Pat -> Exp -> Stmt
    Generator a b = H.Generator () (a :: Pat) (b :: Exp) :: Stmt
    pattern $mQualifier :: forall {r}. Stmt -> (Exp -> r) -> ((# #) -> r) -> r
    $bQualifier :: Exp -> Stmt
    Qualifier a = H.Qualifier () (a :: Exp) :: Stmt
    pattern $mLetStmt :: forall {r}. Stmt -> (Binds -> r) -> ((# #) -> r) -> r
    $bLetStmt :: Binds -> Stmt
    LetStmt a = H.LetStmt () (a :: Binds) :: Stmt
    pattern $mRecStmt :: forall {r}. Stmt -> ([Stmt] -> r) -> ((# #) -> r) -> r
    $bRecStmt :: [Stmt] -> Stmt
    RecStmt a = H.RecStmt () (a :: [Stmt]) :: Stmt

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Generator, Qualifier, LetStmt, RecStmt #-}
    #endif

    -- ** `H.QualStmt`
    type QualStmt = H.QualStmt ()
    pattern $mQualStmt :: forall {r}. QualStmt -> (Stmt -> r) -> ((# #) -> r) -> r
    $bQualStmt :: Stmt -> QualStmt
    QualStmt a = H.QualStmt () (a :: Stmt) :: QualStmt
    pattern $mThenTrans :: forall {r}. QualStmt -> (Exp -> r) -> ((# #) -> r) -> r
    $bThenTrans :: Exp -> QualStmt
    ThenTrans a = H.ThenTrans () (a :: Exp) :: QualStmt
    pattern $mThenBy :: forall {r}. QualStmt -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bThenBy :: Exp -> Exp -> QualStmt
    ThenBy a b = H.ThenBy () (a :: Exp) (b :: Exp) :: QualStmt
    pattern $mGroupBy :: forall {r}. QualStmt -> (Exp -> r) -> ((# #) -> r) -> r
    $bGroupBy :: Exp -> QualStmt
    GroupBy a = H.GroupBy () (a :: Exp) :: QualStmt
    pattern $mGroupUsing :: forall {r}. QualStmt -> (Exp -> r) -> ((# #) -> r) -> r
    $bGroupUsing :: Exp -> QualStmt
    GroupUsing a = H.GroupUsing () (a :: Exp) :: QualStmt
    pattern $mGroupByUsing :: forall {r}. QualStmt -> (Exp -> Exp -> r) -> ((# #) -> r) -> r
    $bGroupByUsing :: Exp -> Exp -> QualStmt
    GroupByUsing a b = H.GroupByUsing () (a :: Exp) (b :: Exp) :: QualStmt

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE QualStmt, ThenTrans, ThenBy, GroupBy, GroupUsing, GroupByUsing #-}
    #endif

    -- ** `H.FieldUpdate`
    type FieldUpdate = H.FieldUpdate ()
    pattern $mFieldUpdate :: forall {r}. FieldUpdate -> (QName -> Exp -> r) -> ((# #) -> r) -> r
    $bFieldUpdate :: QName -> Exp -> FieldUpdate
    FieldUpdate a b = H.FieldUpdate () (a :: QName) (b :: Exp) :: FieldUpdate
    pattern $mFieldPun :: forall {r}. FieldUpdate -> (QName -> r) -> ((# #) -> r) -> r
    $bFieldPun :: QName -> FieldUpdate
    FieldPun a = H.FieldPun () (a :: QName) :: FieldUpdate
    pattern $mFieldWildcard :: forall {r}. FieldUpdate -> ((# #) -> r) -> ((# #) -> r) -> r
    $bFieldWildcard :: FieldUpdate
    FieldWildcard = H.FieldWildcard () :: FieldUpdate

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE FieldUpdate, FieldPun, FieldWildcard #-}
    #endif

    -- ** `H.Alt`
    type Alt = H.Alt ()
    pattern $mAlt :: forall {r}.
    Alt -> (Pat -> Rhs -> Maybe Binds -> r) -> ((# #) -> r) -> r
    $bAlt :: Pat -> Rhs -> Maybe Binds -> Alt
    Alt a b c = H.Alt () (a :: Pat) (b :: Rhs) (c :: (Maybe Binds)) :: Alt

    #if MIN_VERSION_GLASGOW_HASKELL(8,2,1,0)
    {-# COMPLETE Alt #-}
    #endif

    -- * Functions

    prelude_mod, main_mod :: ModuleName
    prelude_mod :: ModuleName
    prelude_mod = () -> ModuleName
    forall l. l -> ModuleName l
    H.prelude_mod ()
    main_mod :: ModuleName
    main_mod = () -> ModuleName
    forall l. l -> ModuleName l
    H.main_mod ()

    main_name :: Name
    main_name :: Name
    main_name = () -> Name
    forall l. l -> Name l
    H.main_name ()

    unit_con_name :: QName
    unit_con_name :: QName
    unit_con_name = () -> QName
    forall l. l -> QName l
    H.unit_con_name ()

    tuple_con_name :: Boxed -> Int -> QName
    tuple_con_name :: Boxed -> Int -> QName
    tuple_con_name = () -> Boxed -> Int -> QName
    forall l. l -> Boxed -> Int -> QName l
    H.tuple_con_name ()

    list_con_name :: QName
    list_con_name :: QName
    list_con_name = () -> QName
    forall l. l -> QName l
    H.list_con_name ()

    list_cons_name :: QName
    list_cons_name :: QName
    list_cons_name = () -> QName
    forall l. l -> QName l
    H.list_cons_name ()

    unboxed_singleton_con_name :: QName
    unboxed_singleton_con_name :: QName
    unboxed_singleton_con_name = () -> QName
    forall l. l -> QName l
    H.unboxed_singleton_con_name ()

    unit_con :: Exp
    unit_con :: Exp
    unit_con = () -> Exp
    forall l. l -> Exp l
    H.unit_con ()

    tuple_con :: Boxed -> Int -> Exp
    tuple_con :: Boxed -> Int -> Exp
    tuple_con = () -> Boxed -> Int -> Exp
    forall l. l -> Boxed -> Int -> Exp l
    H.tuple_con ()

    unboxed_singleton_con :: Exp
    unboxed_singleton_con :: Exp
    unboxed_singleton_con = () -> Exp
    forall l. l -> Exp l
    H.unboxed_singleton_con ()

    as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: Name
    as_name :: Name
    as_name = () -> Name
    forall l. l -> Name l
    H.as_name ()
    qualified_name :: Name
    qualified_name = () -> Name
    forall l. l -> Name l
    H.qualified_name ()
    hiding_name :: Name
    hiding_name = () -> Name
    forall l. l -> Name l
    H.hiding_name ()
    minus_name :: Name
    minus_name = () -> Name
    forall l. l -> Name l
    H.minus_name ()
    bang_name :: Name
    bang_name = () -> Name
    forall l. l -> Name l
    H.bang_name ()
    dot_name :: Name
    dot_name = () -> Name
    forall l. l -> Name l
    H.dot_name ()
    star_name :: Name
    star_name = () -> Name
    forall l. l -> Name l
    H.star_name ()

    hole_name :: QName
    hole_name :: QName
    hole_name = () -> QName
    forall l. l -> QName l
    H.hole_name ()

    export_name, safe_name, unsafe_name, interruptible_name, threadsafe_name, stdcall_name, ccall_name, cplusplus_name, dotnet_name, jvm_name, js_name, javascript_name, capi_name, forall_name, family_name, role_name, stock_name, anyclass_name, via_name :: Name
    export_name :: Name
    export_name = () -> Name
    forall l. l -> Name l
    H.export_name ()
    safe_name :: Name
    safe_name = () -> Name
    forall l. l -> Name l
    H.safe_name ()
    unsafe_name :: Name
    unsafe_name = () -> Name
    forall l. l -> Name l
    H.unsafe_name ()
    interruptible_name :: Name
    interruptible_name = () -> Name
    forall l. l -> Name l
    H.interruptible_name ()
    threadsafe_name :: Name
    threadsafe_name = () -> Name
    forall l. l -> Name l
    H.threadsafe_name ()
    stdcall_name :: Name
    stdcall_name = () -> Name
    forall l. l -> Name l
    H.stdcall_name ()
    ccall_name :: Name
    ccall_name = () -> Name
    forall l. l -> Name l
    H.ccall_name ()
    cplusplus_name :: Name
    cplusplus_name = () -> Name
    forall l. l -> Name l
    H.cplusplus_name ()
    dotnet_name :: Name
    dotnet_name = () -> Name
    forall l. l -> Name l
    H.dotnet_name ()
    jvm_name :: Name
    jvm_name = () -> Name
    forall l. l -> Name l
    H.jvm_name ()
    js_name :: Name
    js_name = () -> Name
    forall l. l -> Name l
    H.js_name ()
    javascript_name :: Name
    javascript_name = () -> Name
    forall l. l -> Name l
    H.javascript_name ()
    capi_name :: Name
    capi_name = () -> Name
    forall l. l -> Name l
    H.capi_name ()
    forall_name :: Name
    forall_name = () -> Name
    forall l. l -> Name l
    H.forall_name ()
    family_name :: Name
    family_name = () -> Name
    forall l. l -> Name l
    H.family_name ()
    role_name :: Name
    role_name = () -> Name
    forall l. l -> Name l
    H.role_name ()
    stock_name :: Name
    stock_name = () -> Name
    forall l. l -> Name l
    H.stock_name ()
    anyclass_name :: Name
    anyclass_name = () -> Name
    forall l. l -> Name l
    H.anyclass_name ()
    via_name :: Name
    via_name = () -> Name
    forall l. l -> Name l
    H.via_name ()

    unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: QName
    unit_tycon_name :: QName
    unit_tycon_name = () -> QName
    forall l. l -> QName l
    H.unit_tycon_name ()
    fun_tycon_name :: QName
    fun_tycon_name = () -> QName
    forall l. l -> QName l
    H.fun_tycon_name ()
    list_tycon_name :: QName
    list_tycon_name = () -> QName
    forall l. l -> QName l
    H.list_tycon_name ()
    unboxed_singleton_tycon_name :: QName
    unboxed_singleton_tycon_name = () -> QName
    forall l. l -> QName l
    H.unboxed_singleton_tycon_name ()

    tuple_tycon_name :: Boxed -> Int -> QName
    tuple_tycon_name :: Boxed -> Int -> QName
    tuple_tycon_name = () -> Boxed -> Int -> QName
    forall l. l -> Boxed -> Int -> QName l
    H.tuple_tycon_name ()

    unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: Type
    unit_tycon :: Type
    unit_tycon = () -> Type
    forall l. l -> Type l
    H.unit_tycon ()
    fun_tycon :: Type
    fun_tycon = () -> Type
    forall l. l -> Type l
    H.fun_tycon ()
    list_tycon :: Type
    list_tycon = () -> Type
    forall l. l -> Type l
    H.list_tycon ()
    unboxed_singleton_tycon :: Type
    unboxed_singleton_tycon = () -> Type
    forall l. l -> Type l
    H.unboxed_singleton_tycon ()

    tuple_tycon :: Boxed -> Int -> Type
    tuple_tycon :: Boxed -> Int -> Type
    tuple_tycon = () -> Boxed -> Int -> Type
    forall l. l -> Boxed -> Int -> Type l
    H.tuple_tycon ()

    -- skipped: (=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool

    -- skipped: class Annotated ast