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

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

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

-- * Datatypes and Constructors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- skipped: data Boxed

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

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

-- ** `H.Kind`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#undef where

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- skipped: data Tool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- * Functions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- skipped: class Annotated ast