{-# 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 $bModuleName :: String -> ModuleName
$mModuleName :: forall {r}. ModuleName -> (String -> r) -> (Void# -> r) -> r
ModuleName a = H.ModuleName () (a :: String) :: ModuleName

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

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

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

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

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

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

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

-- ** `H.Module`
type Module = H.Module ()
pattern $bModule :: Maybe ModuleHead
-> [ModulePragma] -> [ImportDecl] -> [Decl] -> Module
$mModule :: forall {r}.
Module
-> (Maybe ModuleHead
    -> [ModulePragma] -> [ImportDecl] -> [Decl] -> r)
-> (Void# -> r)
-> r
Module a b c d = H.Module () (a :: (Maybe ModuleHead)) (b :: [ModulePragma]) (c :: [ImportDecl]) (d :: [Decl]) :: Module
pattern $bXmlPage :: ModuleName
-> [ModulePragma]
-> XName
-> [XAttr]
-> Maybe Exp
-> [Exp]
-> Module
$mXmlPage :: forall {r}.
Module
-> (ModuleName
    -> [ModulePragma] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> r)
-> (Void# -> r)
-> r
XmlPage a b c d e f = H.XmlPage () (a :: ModuleName) (b :: [ModulePragma]) (c :: XName) (d :: [XAttr]) (e :: (Maybe Exp)) (f :: [Exp]) :: Module
pattern $bXmlHybrid :: Maybe ModuleHead
-> [ModulePragma]
-> [ImportDecl]
-> [Decl]
-> XName
-> [XAttr]
-> Maybe Exp
-> [Exp]
-> Module
$mXmlHybrid :: forall {r}.
Module
-> (Maybe ModuleHead
    -> [ModulePragma]
    -> [ImportDecl]
    -> [Decl]
    -> XName
    -> [XAttr]
    -> Maybe Exp
    -> [Exp]
    -> r)
-> (Void# -> r)
-> r
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 $bModuleHead :: ModuleName
-> Maybe WarningText -> Maybe ExportSpecList -> ModuleHead
$mModuleHead :: forall {r}.
ModuleHead
-> (ModuleName -> Maybe WarningText -> Maybe ExportSpecList -> r)
-> (Void# -> r)
-> r
ModuleHead a b c = H.ModuleHead () (a :: ModuleName) (b :: (Maybe WarningText)) (c :: (Maybe ExportSpecList)) :: ModuleHead

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

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

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

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

-- ** `H.ImportDecl`
type ImportDecl = H.ImportDecl ()
pattern $bImportDecl :: ModuleName
-> Bool
-> Bool
-> Bool
-> Maybe String
-> Maybe ModuleName
-> Maybe (ImportSpecList ())
-> ImportDecl
$mImportDecl :: forall {r}.
ImportDecl
-> (ModuleName
    -> Bool
    -> Bool
    -> Bool
    -> Maybe String
    -> Maybe ModuleName
    -> Maybe (ImportSpecList ())
    -> r)
-> (Void# -> r)
-> r
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 $bImportSpecList :: Bool -> [ImportSpec] -> ImportSpecList ()
$mImportSpecList :: forall {r}.
ImportSpecList ()
-> (Bool -> [ImportSpec] -> r) -> (Void# -> r) -> r
ImportSpecList a b = H.ImportSpecList () (a :: Bool) (b :: [ImportSpec]) :: ImportSpecList

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- ** `H.Match`
type Match = H.Match ()
pattern $bMatch :: Name -> [Pat] -> Rhs -> Maybe Binds -> Match
$mMatch :: forall {r}.
Match
-> (Name -> [Pat] -> Rhs -> Maybe Binds -> r) -> (Void# -> r) -> r
Match a b c d = H.Match () (a :: Name) (b :: [Pat]) (c :: Rhs) (d :: (Maybe Binds)) :: Match
pattern $bInfixMatch :: Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> Match
$mInfixMatch :: forall {r}.
Match
-> (Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> r)
-> (Void# -> r)
-> r
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 $bQualConDecl :: Maybe [TyVarBind] -> Maybe Context -> ConDecl -> QualConDecl
$mQualConDecl :: forall {r}.
QualConDecl
-> (Maybe [TyVarBind] -> Maybe Context -> ConDecl -> r)
-> (Void# -> r)
-> r
QualConDecl a b c = H.QualConDecl () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: ConDecl) :: QualConDecl

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

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

-- ** `H.GadtDecl`
type GadtDecl = H.GadtDecl ()
pattern $bGadtDecl :: Name
-> Maybe [TyVarBind]
-> Maybe Context
-> Maybe [FieldDecl]
-> Type
-> GadtDecl
$mGadtDecl :: forall {r}.
GadtDecl
-> (Name
    -> Maybe [TyVarBind]
    -> Maybe Context
    -> Maybe [FieldDecl]
    -> Type
    -> r)
-> (Void# -> r)
-> r
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 $bClsDecl :: Decl -> ClassDecl
$mClsDecl :: forall {r}. ClassDecl -> (Decl -> r) -> (Void# -> r) -> r
ClsDecl a = H.ClsDecl () (a :: Decl) :: ClassDecl
pattern $bClsDataFam :: Maybe Context -> DeclHead -> Maybe ResultSig -> ClassDecl
$mClsDataFam :: forall {r}.
ClassDecl
-> (Maybe Context -> DeclHead -> Maybe ResultSig -> r)
-> (Void# -> r)
-> r
ClsDataFam a b c = H.ClsDataFam () (a :: (Maybe Context)) (b :: DeclHead) (c :: (Maybe ResultSig)) :: ClassDecl
pattern $bClsTyFam :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> ClassDecl
$mClsTyFam :: forall {r}.
ClassDecl
-> (DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> r)
-> (Void# -> r)
-> r
ClsTyFam a b c = H.ClsTyFam () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) :: ClassDecl
pattern $bClsTyDef :: TypeEqn -> ClassDecl
$mClsTyDef :: forall {r}. ClassDecl -> (TypeEqn -> r) -> (Void# -> r) -> r
ClsTyDef a = H.ClsTyDef () (a :: TypeEqn) :: ClassDecl
pattern $bClsDefSig :: Name -> Type -> ClassDecl
$mClsDefSig :: forall {r}. ClassDecl -> (Name -> Type -> r) -> (Void# -> r) -> r
ClsDefSig a b = H.ClsDefSig () (a :: Name) (b :: Type) :: ClassDecl

-- ** `H.InstDecl`
type InstDecl = H.InstDecl ()
pattern $bInsDecl :: Decl -> InstDecl
$mInsDecl :: forall {r}. InstDecl -> (Decl -> r) -> (Void# -> r) -> r
InsDecl a = H.InsDecl () (a :: Decl) :: InstDecl
pattern $bInsType :: Type -> Type -> InstDecl
$mInsType :: forall {r}. InstDecl -> (Type -> Type -> r) -> (Void# -> r) -> r
InsType a b = H.InsType () (a :: Type) (b :: Type) :: InstDecl
pattern $bInsData :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> InstDecl
$mInsData :: forall {r}.
InstDecl
-> (DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> r)
-> (Void# -> r)
-> r
InsData a b c d = H.InsData () (a :: DataOrNew) (b :: Type) (c :: [QualConDecl]) (d :: [Deriving]) :: InstDecl
pattern $bInsGData :: DataOrNew
-> Type -> Maybe Type -> [GadtDecl] -> [Deriving] -> InstDecl
$mInsGData :: forall {r}.
InstDecl
-> (DataOrNew
    -> Type -> Maybe Type -> [GadtDecl] -> [Deriving] -> r)
-> (Void# -> r)
-> r
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 $bBangedTy :: BangType
$mBangedTy :: forall {r}. BangType -> (Void# -> r) -> (Void# -> r) -> r
BangedTy = H.BangedTy () :: BangType
pattern $bLazyTy :: BangType
$mLazyTy :: forall {r}. BangType -> (Void# -> r) -> (Void# -> r) -> r
LazyTy = H.LazyTy () :: BangType
pattern $bNoStrictAnnot :: BangType
$mNoStrictAnnot :: forall {r}. BangType -> (Void# -> r) -> (Void# -> r) -> r
NoStrictAnnot = H.NoStrictAnnot () :: BangType

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

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

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

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

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

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

-- skipped: data Boxed

-- ** `H.TyVarBind`
type TyVarBind = H.TyVarBind ()
pattern $bKindedVar :: Name -> Type -> TyVarBind
$mKindedVar :: forall {r}. TyVarBind -> (Name -> Type -> r) -> (Void# -> r) -> r
KindedVar a b = H.KindedVar () (a :: Name) (b :: Kind) :: TyVarBind
pattern $bUnkindedVar :: Name -> TyVarBind
$mUnkindedVar :: forall {r}. TyVarBind -> (Name -> r) -> (Void# -> r) -> r
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 $bFunDep :: [Name] -> [Name] -> FunDep
$mFunDep :: forall {r}. FunDep -> ([Name] -> [Name] -> r) -> (Void# -> r) -> r
FunDep a b = H.FunDep () (a :: [Name]) (b :: [Name]) :: FunDep

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

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

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

pattern $bChar :: Char -> Literal
$mChar :: forall {r}. Literal -> (Char -> r) -> (Void# -> r) -> r
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 $bString :: String -> Literal
$mString :: forall {r}. Literal -> (String -> r) -> (Void# -> r) -> r
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 $bInt :: Integer -> Literal
$mInt :: forall {r}. Literal -> (Integer -> r) -> (Void# -> r) -> r
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 $bFrac :: Rational -> Literal
$mFrac :: forall {r}. Literal -> (Rational -> r) -> (Void# -> r) -> r
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 $bPrimInt :: Integer -> Literal
$mPrimInt :: forall {r}. Literal -> (Integer -> r) -> (Void# -> r) -> r
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 $bPrimWord :: Integer -> Literal
$mPrimWord :: forall {r}. Literal -> (Integer -> r) -> (Void# -> r) -> r
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 $bPrimFloat :: Rational -> Literal
$mPrimFloat :: forall {r}. Literal -> (Rational -> r) -> (Void# -> r) -> r
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 $bPrimDouble :: Rational -> Literal
$mPrimDouble :: forall {r}. Literal -> (Rational -> r) -> (Void# -> r) -> r
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 $bPrimChar :: Char -> Literal
$mPrimChar :: forall {r}. Literal -> (Char -> r) -> (Void# -> r) -> r
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 $bPrimString :: String -> Literal
$mPrimString :: forall {r}. Literal -> (String -> r) -> (Void# -> r) -> r
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 $bSignless :: Sign
$mSignless :: forall {r}. Sign -> (Void# -> r) -> (Void# -> r) -> r
Signless = H.Signless () :: Sign
pattern $bNegative :: Sign
$mNegative :: forall {r}. Sign -> (Void# -> r) -> (Void# -> r) -> r
Negative = H.Negative () :: Sign

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

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

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

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

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

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

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

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

-- skipped: data Tool

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

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

-- ** `H.Rule`
type Rule = H.Rule ()
pattern $bRule :: String -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> Rule
$mRule :: forall {r}.
Rule
-> (String
    -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> r)
-> (Void# -> r)
-> r
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 $bRuleVar :: Name -> RuleVar
$mRuleVar :: forall {r}. RuleVar -> (Name -> r) -> (Void# -> r) -> r
RuleVar a = H.RuleVar () (a :: Name) :: RuleVar
pattern $bTypedRuleVar :: Name -> Type -> RuleVar
$mTypedRuleVar :: forall {r}. RuleVar -> (Name -> Type -> r) -> (Void# -> r) -> r
TypedRuleVar a b = H.TypedRuleVar () (a :: Name) (b :: Type) :: RuleVar

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

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

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

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

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

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

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

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

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

-- ** `H.Alt`
type Alt = H.Alt ()
pattern $bAlt :: Pat -> Rhs -> Maybe Binds -> Alt
$mAlt :: forall {r}.
Alt -> (Pat -> Rhs -> Maybe Binds -> r) -> (Void# -> r) -> r
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