{-# 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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `H.Promoted`
type  = 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

-- 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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- 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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- ** `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

-- * 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