diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,5 @@
+# Revision history for haskell-src-exts-simple
+
+## 1.18.0  -- 2016-08-??
+
+* Initial release.
diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
new file mode 100644
--- /dev/null
+++ b/COMPATIBILITY.md
@@ -0,0 +1,19 @@
+# Compatibility notes for haskell-src-exts-simple
+
+## Comparison to haskell-src-exts 1.17 (as of version 1.18):
+
+haskell-src-exts-simple provides a simplified view of the annotated AST in haskell-src-exts, so there are differences to the unannotated AST provided by earlier versions of haskell-src-exts:
+
+* some constructors carried `SrcLoc` information, which is no longer available, notably
+  - most constructors of the `Decl`, `ModulePragma`, `ImportDecl`, `IPBind`, `ClassDecl`, `InstDecl`, `QualConDecl`, `GadtDecl` datatypes
+  - the `Lambda`, `ExpTypeSig` and `Proc` constructors of the `Exp` type (and a few XML related ones)
+  - the `Generator` constructor of `Stmt`
+  - the `Alt` constructor of `Alt`
+  - the `PatTypeSig` constructor of `Pat`
+* the first three fields (not counting the `SrcLoc`) of the `Module` constructor have been combined into a single field with `ModuleHead` type
+
+(this list is probably incomplete)
+
+## ghc versions
+
+* haskell-src-exts-simple requires ghc-7.10 or later, because it relies on bidirectional pattern synonyms
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2016 Bertram Felgenhauer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,10 @@
+# haskell-src-exts-simple
+
+This package provides a shim for haskell-src-exts, exposing the same
+AST but without annotations.
+
+This package is useful for synthesizing and manipulating HSE ASTs
+that don't carry source location information. It may also aid
+in porting packages from haskell-src-exts 1.17 to 1.18, but it
+is not a drop-in replacement for the old annotation-free AST.
+See [COMPATIBILITY.md](COMPATIBILITY.md) for details.
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/haskell-src-exts-simple.cabal b/haskell-src-exts-simple.cabal
new file mode 100644
--- /dev/null
+++ b/haskell-src-exts-simple.cabal
@@ -0,0 +1,55 @@
+name:                haskell-src-exts-simple
+version:             1.18.0.0
+synopsis:            A simplified view on the haskell-src-exts AST
+description:
+    This package provides a shim for haskell-src-exts (HSE), exposing the
+    same AST but without annotations.
+    .
+    This package is useful for synthesizing and manipulating HSE ASTs
+    that don't carry source location information. It may also aid
+    in porting packages from haskell-src-exts 1.17 to 1.18, but it
+    is not a drop-in replacement for the old annotation-free AST.
+    See COMPATIBILITY.md for details.
+    .
+    See "Language.Haskell.Exts.Simple" for further information.
+    .
+    __Versioning notice__: To be able to track the haskell-src-exts version
+    numbers conveniently, the first __three__ components of the version
+    will be treated as the major version, followed by the minor version
+    as usual.
+license:             MIT
+license-file:        LICENSE
+author:              Bertram Felgenhauer
+maintainer:          Bertram Felgenhauer <int-e@gmx.de>
+copyright:           2016, Bertram Felgenhauer
+category:            Development
+build-type:          Simple
+extra-source-files:
+    README.md,
+    COMPATIBILITY.md,
+    CHANGELOG.md
+homepage:            https://github.com/int-e/haskell-src-exts-simple
+cabal-version:       >=1.10
+
+source-repository head
+    type:            git
+    location:        https://github.com/int-e/haskell-src-exts-simple
+
+library
+    exposed-modules:
+        Language.Haskell.Exts.Simple,
+        Language.Haskell.Exts.Simple.Build,
+        Language.Haskell.Exts.Simple.Extension,
+        Language.Haskell.Exts.Simple.Fixity,
+        Language.Haskell.Exts.Simple.Parser,
+        Language.Haskell.Exts.Simple.Pretty,
+        Language.Haskell.Exts.Simple.Syntax
+    -- other-modules:       
+    other-extensions:
+        PatternSynonyms,
+        ScopedTypeVariables
+    build-depends:
+        base >= 4.8 && < 5,
+        haskell-src-exts >= 1.18 && < 1.19
+    hs-source-dirs:      src
+    default-language:    Haskell2010
diff --git a/src/Language/Haskell/Exts/Simple.hs b/src/Language/Haskell/Exts/Simple.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple.hs
@@ -0,0 +1,53 @@
+-- |
+-- This module exports all relevant modules of the haskell-src-exts-simple package.
+--
+-- The most important module is "Language.Haskell.Exts.Simple.Syntax".
+
+{-# LANGUAGE PatternSynonyms #-}
+module Language.Haskell.Exts.Simple (
+    module Language.Haskell.Exts.Simple.Syntax,
+    module Language.Haskell.Exts.Simple.Build,
+    module Language.Haskell.Exts.Simple.Pretty,
+    module Language.Haskell.Exts.Simple.Fixity,
+    module Language.Haskell.Exts.Simple.Extension,
+    module Language.Haskell.Exts.Simple.Parser,
+    module Language.Haskell.Exts.SrcLoc,
+    module Language.Haskell.Exts.Simple
+) where
+
+import qualified Language.Haskell.Exts as H
+import Language.Haskell.Exts (
+    readExtensions,
+ )
+
+import Language.Haskell.Exts.Simple.Syntax
+import Language.Haskell.Exts.Simple.Build
+import Language.Haskell.Exts.Simple.Pretty
+import Language.Haskell.Exts.Simple.Fixity
+import Language.Haskell.Exts.Simple.Extension
+import Language.Haskell.Exts.Simple.Parser
+import Language.Haskell.Exts.SrcLoc -- useful for interpreting parse errors
+
+-- * Functions
+
+parseFile :: FilePath -> IO (ParseResult Module)
+parseFile = fmap (fmap (fmap (const ()))) . H.parseFile
+
+parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult Module)
+parseFileWithExts e = fmap (fmap (fmap (const ()))) . H.parseFileWithExts e
+
+
+parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult Module)
+parseFileWithMode m = fmap (fmap (fmap (const ()))) . H.parseFileWithMode m
+
+
+parseFileContents :: String -> ParseResult Module
+parseFileContents = fmap (fmap (const ())) . H.parseFileContents
+
+parseFileContentsWithExts :: [Extension] -> String -> ParseResult Module
+parseFileContentsWithExts e =
+    fmap (fmap (const ())) . H.parseFileContentsWithExts e
+
+parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module
+parseFileContentsWithMode m =
+    fmap (fmap (const ())) . H.parseFileContentsWithMode m
diff --git a/src/Language/Haskell/Exts/Simple/Build.hs b/src/Language/Haskell/Exts/Simple/Build.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple/Build.hs
@@ -0,0 +1,8 @@
+-- |
+-- This module reexports "Language.Haskell.Exts.Build".
+
+module Language.Haskell.Exts.Simple.Build (
+    module Language.Haskell.Exts.Build
+) where
+
+import Language.Haskell.Exts.Build
diff --git a/src/Language/Haskell/Exts/Simple/Extension.hs b/src/Language/Haskell/Exts/Simple/Extension.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple/Extension.hs
@@ -0,0 +1,8 @@
+-- |
+-- This module reexports "Language.Haskell.Exts.Extension".
+
+module Language.Haskell.Exts.Simple.Extension (
+    module Language.Haskell.Exts.Extension
+) where
+
+import Language.Haskell.Exts.Extension
diff --git a/src/Language/Haskell/Exts/Simple/Fixity.hs b/src/Language/Haskell/Exts/Simple/Fixity.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple/Fixity.hs
@@ -0,0 +1,22 @@
+-- |
+-- This module reexports "Language.Haskell.Exts.Fixity", adapting `applyFixityies`.
+
+module Language.Haskell.Exts.Simple.Fixity (
+    module Language.Haskell.Exts.Simple.Fixity,
+    module Language.Haskell.Exts.Fixity
+) where
+
+import qualified Language.Haskell.Exts.Fixity as H
+import Language.Haskell.Exts.Fixity (
+    Fixity(..),
+    infix_, infixl_, infixr_,
+    preludeFixities, baseFixities,
+    AppFixity,
+ )
+import Language.Haskell.Exts.Simple.Syntax
+import Language.Haskell.Exts.SrcLoc
+
+-- * Functions
+
+applyFixities :: (AppFixity ast, Functor ast, Monad m) => [Fixity] -> ast () -> m (ast ())
+applyFixities fixs = fmap (fmap (const ())) . H.applyFixities fixs . fmap (const noSrcSpan)
diff --git a/src/Language/Haskell/Exts/Simple/Parser.hs b/src/Language/Haskell/Exts/Simple/Parser.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple/Parser.hs
@@ -0,0 +1,94 @@
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+-- |
+-- This module reexports "Language.Haskell.Exts.Parser" with adaptations.
+
+module Language.Haskell.Exts.Simple.Parser (
+    module Language.Haskell.Exts.Simple.Parser,
+    module Language.Haskell.Exts.Parser
+) where
+
+import qualified Language.Haskell.Exts.Parser as H
+import qualified Language.Haskell.Exts.SrcLoc as H
+import Language.Haskell.Exts.Parser (
+    Parseable,
+    ParseResult (..),
+    ParseMode (..),
+    defaultParseMode,
+    fromParseResult,
+    NonGreedy (..),
+    unListOf,
+ )
+
+import Language.Haskell.Exts.Simple.Syntax
+
+-- * Datatypes and Constructors
+
+-- ** `H.ListOf`
+type ListOf = H.ListOf
+pattern ListOf a <- H.ListOf _ a where ListOf a = H.ListOf H.noSrcSpan a
+
+-- ** `H.PragmasAndModuleName`
+type PragmasAndModuleName = H.PragmasAndModuleName ()
+pattern PragmasAndModuleName a b = H.PragmasAndModuleName () (a :: [ModulePragma]) (b :: Maybe ModuleName) :: PragmasAndModuleName
+
+-- ** `H.PragmasAndModuleHead`
+type PragmasAndModuleHead = H.PragmasAndModuleHead ()
+pattern PragmasAndModuleHead a b = H.PragmasAndModuleHead () (a :: [ModulePragma]) (b :: Maybe ModuleHead)
+
+-- ** `H.ModuleHeadAndImports`
+type ModuleHeadAndImports = H.ModuleHeadAndImports ()
+pattern ModuleHeadAndImports a b c = H.ModuleHeadAndImports () (a :: [ModulePragma]) (b :: Maybe ModuleHead) (c :: [ImportDecl])
+
+-- * Functions
+
+parse :: (Parseable (ast H.SrcSpanInfo), Functor ast) => String -> ParseResult (ast ())
+parse = fmap (fmap (const () :: H.SrcSpanInfo -> ())) . H.parse
+
+parseWithMode :: (Parseable (ast H.SrcSpanInfo), Functor ast) => ParseMode -> String -> ParseResult (ast ())
+parseWithMode m = fmap (fmap (const () :: H.SrcSpanInfo -> ())) . H.parseWithMode m
+
+parseModule :: String -> ParseResult Module
+parseModule = fmap (fmap (const ())) . H.parseModule
+
+parseModuleWithMode :: ParseMode -> String -> ParseResult Module
+parseModuleWithMode m = fmap (fmap (const ())) . H.parseModuleWithMode m
+
+parseExp :: String -> ParseResult Exp
+parseExp = fmap (fmap (const ())) . H.parseExp
+
+parseExpWithMode :: ParseMode -> String -> ParseResult Exp
+parseExpWithMode m = fmap (fmap (const ())) . H.parseExpWithMode m
+
+parseStmt :: String -> ParseResult Stmt
+parseStmt = fmap (fmap (const ())) . H.parseStmt
+
+parseStmtWithMode :: ParseMode -> String -> ParseResult Stmt
+parseStmtWithMode m = fmap (fmap (const ())) . H.parseStmtWithMode m
+
+parsePat :: String -> ParseResult Pat
+parsePat = fmap (fmap (const ())) . H.parsePat
+
+parsePatWithMode :: ParseMode -> String -> ParseResult Pat
+parsePatWithMode m = fmap (fmap (const ())) . H.parsePatWithMode m
+
+parseDecl :: String -> ParseResult Decl
+parseDecl = fmap (fmap (const ())) . H.parseDecl
+
+parseDeclWithMode :: ParseMode -> String -> ParseResult Decl
+parseDeclWithMode m = fmap (fmap (const ())) . H.parseDeclWithMode m
+
+parseType :: String -> ParseResult Type
+parseType = fmap (fmap (const ())) . H.parseType
+
+parseTypeWithMode :: ParseMode -> String -> ParseResult Type
+parseTypeWithMode m = fmap (fmap (const ())) . H.parseTypeWithMode m
+
+parseImportDecl :: String -> ParseResult ImportDecl
+parseImportDecl = fmap (fmap (const ())) . H.parseImportDecl
+
+parseImportDeclWithMode :: ParseMode -> String -> ParseResult ImportDecl
+parseImportDeclWithMode m = fmap (fmap (const ())) . H.parseImportDeclWithMode m
+
+getTopPragmas :: String -> ParseResult [ModulePragma]
+getTopPragmas = fmap (fmap (fmap (const ()))) . H.getTopPragmas
diff --git a/src/Language/Haskell/Exts/Simple/Pretty.hs b/src/Language/Haskell/Exts/Simple/Pretty.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple/Pretty.hs
@@ -0,0 +1,8 @@
+-- |
+-- This module reexports "Language.Haskell.Exts.Pretty".
+
+module Language.Haskell.Exts.Simple.Pretty (
+    module Language.Haskell.Exts.Pretty
+) where
+
+import Language.Haskell.Exts.Pretty
diff --git a/src/Language/Haskell/Exts/Simple/Syntax.hs b/src/Language/Haskell/Exts/Simple/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/Language/Haskell/Exts/Simple/Syntax.hs
@@ -0,0 +1,694 @@
+{-# 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 ModuleName a = H.ModuleName () (a :: String) :: ModuleName
+
+-- ** `H.SpecialCon`
+type SpecialCon = H.SpecialCon ()
+pattern UnitCon = H.UnitCon () :: SpecialCon
+pattern ListCon = H.ListCon () :: SpecialCon
+pattern FunCon = H.FunCon () :: SpecialCon
+pattern TupleCon a b = H.TupleCon () (a :: Boxed) (b :: Int) :: SpecialCon
+pattern Cons = H.Cons () :: SpecialCon
+pattern UnboxedSingleCon = H.UnboxedSingleCon () :: SpecialCon
+
+-- ** `H.QName`
+type QName = H.QName ()
+pattern Qual a b = H.Qual () (a :: ModuleName) (b :: Name) :: QName
+pattern UnQual a = H.UnQual () (a :: Name) :: QName
+pattern Special a = H.Special () (a :: SpecialCon) :: QName
+
+-- ** `H.Name`
+type Name = H.Name ()
+pattern Ident a = H.Ident () (a :: String) :: Name
+pattern Symbol a = H.Symbol () (a :: String) :: Name
+
+-- ** `H.IPName`
+type IPName = H.IPName ()
+pattern IPDup a = H.IPDup () (a :: String) :: IPName
+pattern IPLin a = H.IPLin () (a :: String) :: IPName
+
+-- ** `H.QOp`
+type QOp = H.QOp ()
+pattern QVarOp a = H.QVarOp () (a :: QName) :: QOp
+pattern QConOp a = H.QConOp () (a :: QName) :: QOp
+
+-- ** `H.Op`
+type Op = H.Op ()
+pattern VarOp a = H.VarOp () (a :: Name) :: Op
+pattern ConOp a = H.ConOp () (a :: Name) :: Op
+
+-- ** `H.CName`
+type CName = H.CName ()
+pattern VarName a = H.VarName () (a :: Name) :: CName
+pattern ConName a = H.ConName () (a :: Name) :: CName
+
+-- ** `H.Module`
+type Module = H.Module ()
+pattern Module a b c d = H.Module () (a :: (Maybe ModuleHead)) (b :: [ModulePragma]) (c :: [ImportDecl]) (d :: [Decl]) :: Module
+pattern XmlPage a b c d e f = H.XmlPage () (a :: ModuleName) (b :: [ModulePragma]) (c :: XName) (d :: [XAttr]) (e :: (Maybe Exp)) (f :: [Exp]) :: Module
+pattern 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 ModuleHead a b c = H.ModuleHead () (a :: ModuleName) (b :: (Maybe WarningText)) (c :: (Maybe ExportSpecList)) :: ModuleHead
+
+-- ** `H.ExportSpecList`
+type ExportSpecList = H.ExportSpecList ()
+pattern ExportSpecList a = H.ExportSpecList () (a :: [ExportSpec]) :: ExportSpecList
+
+-- ** `H.ExportSpec`
+type ExportSpec = H.ExportSpec ()
+pattern EVar a = H.EVar () (a :: QName) :: ExportSpec
+pattern EAbs a b = H.EAbs () (a :: Namespace) (b :: QName) :: ExportSpec
+pattern EThingWith a b c = H.EThingWith () (a :: EWildcard) (b :: QName) (c :: [CName]) :: ExportSpec
+pattern EModuleContents a = H.EModuleContents () (a :: ModuleName) :: ExportSpec
+
+-- ** `H.EWildcard`
+type EWildcard = H.EWildcard ()
+pattern NoWildcard = H.NoWildcard () :: EWildcard
+pattern EWildcard a = H.EWildcard () (a :: Int) :: EWildcard
+
+-- ** `H.Namespace`
+type Namespace = H.Namespace ()
+pattern NoNamespace = H.NoNamespace () :: Namespace
+pattern TypeNamespace = H.TypeNamespace () :: Namespace
+pattern PatternNamespace = H.PatternNamespace () :: Namespace
+
+-- ** `H.ImportDecl`
+type ImportDecl = H.ImportDecl ()
+-- | Note, this is originally a record constructor, but ghc-7.10 does not support record pattern synonyms. For now, the selectors are exported as functions.
+pattern ImportDecl a b c d e f g = H.ImportDecl () (a :: ModuleName) (b :: Bool) (c :: Bool) (d :: Bool) (e :: Maybe String) (f :: Maybe ModuleName) (g :: Maybe ImportSpecList) :: ImportDecl
+importModule :: ImportDecl -> ModuleName
+importModule = H.importModule
+importQualified :: ImportDecl -> Bool
+importQualified = H.importQualified
+importSrc :: ImportDecl -> Bool
+importSrc = H.importSrc
+importSafe :: ImportDecl -> Bool
+importSafe = H.importSafe
+importPkg :: ImportDecl -> Maybe String
+importPkg = H.importPkg
+importAs :: ImportDecl -> Maybe ModuleName
+importAs = H.importAs
+importSpecs :: ImportDecl -> Maybe ImportSpecList
+importSpecs = H.importSpecs
+
+-- ** `H.ImportSpecList`
+type ImportSpecList = H.ImportSpecList ()
+pattern ImportSpecList a b = H.ImportSpecList () (a :: Bool) (b :: [ImportSpec]) :: ImportSpecList
+
+-- ** `H.ImportSpec`
+type ImportSpec = H.ImportSpec ()
+pattern IVar a = H.IVar () (a :: Name) :: ImportSpec
+pattern IAbs a b = H.IAbs () (a :: Namespace) (b :: Name) :: ImportSpec
+pattern IThingAll a = H.IThingAll () (a :: Name) :: ImportSpec
+pattern IThingWith a b = H.IThingWith () (a :: Name) (b :: [CName]) :: ImportSpec
+
+-- ** `H.Assoc`
+type Assoc = H.Assoc ()
+pattern AssocNone = H.AssocNone () :: Assoc
+pattern AssocLeft = H.AssocLeft () :: Assoc
+pattern AssocRight = H.AssocRight () :: Assoc
+
+-- ** `H.Decl`
+type Decl = H.Decl ()
+pattern TypeDecl a b = H.TypeDecl () (a :: DeclHead) (b :: Type) :: Decl
+pattern TypeFamDecl a b c = H.TypeFamDecl () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) :: Decl
+pattern ClosedTypeFamDecl a b c d = H.ClosedTypeFamDecl () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) (d :: [TypeEqn]) :: Decl
+pattern DataDecl a b c d e = H.DataDecl () (a :: DataOrNew) (b :: (Maybe Context)) (c :: DeclHead) (d :: [QualConDecl]) (e :: (Maybe Deriving)) :: Decl
+pattern GDataDecl a b c d e f = H.GDataDecl () (a :: DataOrNew) (b :: (Maybe Context)) (c :: DeclHead) (d :: (Maybe Kind)) (e :: [GadtDecl]) (f :: (Maybe Deriving)) :: Decl
+pattern DataFamDecl a b c = H.DataFamDecl () (a :: (Maybe Context)) (b :: DeclHead) (c :: (Maybe ResultSig)) :: Decl
+pattern TypeInsDecl a b = H.TypeInsDecl () (a :: Type) (b :: Type) :: Decl
+pattern DataInsDecl a b c d = H.DataInsDecl () (a :: DataOrNew) (b :: Type) (c :: [QualConDecl]) (d :: (Maybe Deriving)) :: Decl
+pattern GDataInsDecl a b c d e = H.GDataInsDecl () (a :: DataOrNew) (b :: Type) (c :: (Maybe Kind)) (d :: [GadtDecl]) (e :: (Maybe Deriving)) :: Decl
+pattern ClassDecl a b c d = H.ClassDecl () (a :: (Maybe Context)) (b :: DeclHead) (c :: [FunDep]) (d :: (Maybe [ClassDecl])) :: Decl
+pattern InstDecl a b c = H.InstDecl () (a :: (Maybe Overlap)) (b :: InstRule) (c :: (Maybe [InstDecl])) :: Decl
+pattern DerivDecl a b = H.DerivDecl () (a :: (Maybe Overlap)) (b :: InstRule) :: Decl
+pattern InfixDecl a b c = H.InfixDecl () (a :: Assoc) (b :: (Maybe Int)) (c :: [Op]) :: Decl
+pattern DefaultDecl a = H.DefaultDecl () (a :: [Type]) :: Decl
+pattern SpliceDecl a = H.SpliceDecl () (a :: Exp) :: Decl
+pattern TypeSig a b = H.TypeSig () (a :: [Name]) (b :: Type) :: Decl
+pattern PatSynSig a b c d e = H.PatSynSig () (a :: Name) (b :: (Maybe [TyVarBind])) (c :: (Maybe Context)) (d :: (Maybe Context)) (e :: Type) :: Decl
+pattern FunBind a = H.FunBind () (a :: [Match]) :: Decl
+pattern PatBind a b c = H.PatBind () (a :: Pat) (b :: Rhs) (c :: (Maybe Binds)) :: Decl
+pattern PatSyn a b c = H.PatSyn () (a :: Pat) (b :: Pat) (c :: PatternSynDirection) :: Decl
+pattern ForImp a b c d e = H.ForImp () (a :: CallConv) (b :: (Maybe Safety)) (c :: (Maybe String)) (d :: Name) (e :: Type) :: Decl
+pattern ForExp a b c d = H.ForExp () (a :: CallConv) (b :: (Maybe String)) (c :: Name) (d :: Type) :: Decl
+pattern RulePragmaDecl a = H.RulePragmaDecl () (a :: [Rule]) :: Decl
+pattern DeprPragmaDecl a = H.DeprPragmaDecl () (a :: [([Name], String)]) :: Decl
+pattern WarnPragmaDecl a = H.WarnPragmaDecl () (a :: [([Name], String)]) :: Decl
+pattern InlineSig a b c = H.InlineSig () (a :: Bool) (b :: (Maybe Activation)) (c :: QName) :: Decl
+pattern InlineConlikeSig a b = H.InlineConlikeSig () (a :: (Maybe Activation)) (b :: QName) :: Decl
+pattern SpecSig a b c = H.SpecSig () (a :: (Maybe Activation)) (b :: QName) (c :: [Type]) :: Decl
+pattern SpecInlineSig a b c d = H.SpecInlineSig () (a :: Bool) (b :: (Maybe Activation)) (c :: QName) (d :: [Type]) :: Decl
+pattern InstSig a = H.InstSig () (a :: InstRule) :: Decl
+pattern AnnPragma a = H.AnnPragma () (a :: Annotation) :: Decl
+pattern MinimalPragma a = H.MinimalPragma () (a :: (Maybe BooleanFormula)) :: Decl
+pattern RoleAnnotDecl a b = H.RoleAnnotDecl () (a :: QName) (b :: [Role]) :: Decl
+
+-- ** `H.PatternSynDirection`
+type PatternSynDirection = H.PatternSynDirection ()
+pattern Unidirectional = H.Unidirectional :: PatternSynDirection
+pattern ImplicitBidirectional = H.ImplicitBidirectional :: PatternSynDirection
+pattern ExplicitBidirectional a = H.ExplicitBidirectional () (a :: [Decl]) :: PatternSynDirection
+
+-- ** `H.TypeEqn`
+type TypeEqn = H.TypeEqn ()
+pattern TypeEqn a b = H.TypeEqn () (a :: Type) (b :: Type) :: TypeEqn
+
+-- ** `H.Annotation`
+type Annotation = H.Annotation ()
+pattern Ann a b = H.Ann () (a :: Name) (b :: Exp) :: Annotation
+pattern TypeAnn a b = H.TypeAnn () (a :: Name) (b :: Exp) :: Annotation
+pattern ModuleAnn a = H.ModuleAnn () (a :: Exp) :: Annotation
+
+-- ** `H.BooleanFormula`
+type BooleanFormula = H.BooleanFormula ()
+pattern VarFormula a = H.VarFormula () (a :: Name) :: BooleanFormula
+pattern AndFormula a = H.AndFormula () (a :: [BooleanFormula]) :: BooleanFormula
+pattern OrFormula a = H.OrFormula () (a :: [BooleanFormula]) :: BooleanFormula
+pattern ParenFormula a = H.ParenFormula () (a :: BooleanFormula) :: BooleanFormula
+
+-- ** `H.Role`
+type Role = H.Role ()
+pattern Nominal = H.Nominal () :: Role
+pattern Representational = H.Representational () :: Role
+pattern Phantom = H.Phantom () :: Role
+pattern RoleWildcard = H.RoleWildcard () :: Role
+
+-- ** `H.DataOrNew`
+type DataOrNew = H.DataOrNew ()
+pattern DataType = H.DataType () :: DataOrNew
+pattern NewType = H.NewType () :: DataOrNew
+
+-- ** `H.InjectivityInfo`
+type InjectivityInfo = H.InjectivityInfo ()
+pattern InjectivityInfo a b = H.InjectivityInfo () (a :: Name) (b :: [Name]) :: InjectivityInfo
+
+-- ** `H.ResultSig`
+type ResultSig = H.ResultSig ()
+pattern KindSig a = H.KindSig () (a :: Kind) :: ResultSig
+pattern TyVarSig a = H.TyVarSig () (a :: TyVarBind) :: ResultSig
+
+-- ** `H.DeclHead`
+type DeclHead = H.DeclHead ()
+pattern DHead a = H.DHead () (a :: Name) :: DeclHead
+pattern DHInfix a b = H.DHInfix () (a :: TyVarBind) (b :: Name) :: DeclHead
+pattern DHParen a = H.DHParen () (a :: DeclHead) :: DeclHead
+pattern DHApp a b = H.DHApp () (a :: DeclHead) (b :: TyVarBind) :: DeclHead
+
+-- ** `H.InstRule`
+type InstRule = H.InstRule ()
+pattern IRule a b c = H.IRule () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: InstHead) :: InstRule
+pattern IParen a = H.IParen () (a :: InstRule) :: InstRule
+
+-- ** `H.InstHead`
+type InstHead = H.InstHead ()
+pattern IHCon a = H.IHCon () (a :: QName) :: InstHead
+pattern IHInfix a b = H.IHInfix () (a :: Type) (b :: QName) :: InstHead
+pattern IHParen a = H.IHParen () (a :: InstHead) :: InstHead
+pattern IHApp a b = H.IHApp () (a :: InstHead) (b :: Type) :: InstHead
+
+-- ** `H.Deriving`
+type Deriving = H.Deriving ()
+pattern Deriving a = H.Deriving () (a :: [InstRule]) :: Deriving
+
+-- ** `H.Binds`
+type Binds = H.Binds ()
+pattern BDecls a = H.BDecls () (a :: [Decl]) :: Binds
+pattern IPBinds a = H.IPBinds () (a :: [IPBind]) :: Binds
+
+-- ** `H.IPBind`
+type IPBind = H.IPBind ()
+pattern IPBind a b = H.IPBind () (a :: IPName) (b :: Exp) :: IPBind
+
+-- ** `H.Match`
+type Match = H.Match ()
+pattern Match a b c d = H.Match () (a :: Name) (b :: [Pat]) (c :: Rhs) (d :: (Maybe Binds)) :: Match
+pattern 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 QualConDecl a b c = H.QualConDecl () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: ConDecl) :: QualConDecl
+
+-- ** `H.ConDecl`
+type ConDecl = H.ConDecl ()
+pattern ConDecl a b = H.ConDecl () (a :: Name) (b :: [Type]) :: ConDecl
+pattern InfixConDecl a b c = H.InfixConDecl () (a :: Type) (b :: Name) (c :: Type) :: ConDecl
+pattern RecDecl a b = H.RecDecl () (a :: Name) (b :: [FieldDecl]) :: ConDecl
+
+-- ** `H.FieldDecl`
+type FieldDecl = H.FieldDecl ()
+pattern FieldDecl a b = H.FieldDecl () (a :: [Name]) (b :: Type) :: FieldDecl
+
+-- ** `H.GadtDecl`
+type GadtDecl = H.GadtDecl ()
+pattern GadtDecl a b c = H.GadtDecl () (a :: Name) (b :: (Maybe [FieldDecl])) (c :: Type) :: GadtDecl
+
+-- ** `H.ClassDecl`
+type ClassDecl = H.ClassDecl ()
+pattern ClsDecl a = H.ClsDecl () (a :: Decl) :: ClassDecl
+pattern ClsDataFam a b c = H.ClsDataFam () (a :: (Maybe Context)) (b :: DeclHead) (c :: (Maybe ResultSig)) :: ClassDecl
+pattern ClsTyFam a b c = H.ClsTyFam () (a :: DeclHead) (b :: (Maybe ResultSig)) (c :: (Maybe InjectivityInfo)) :: ClassDecl
+pattern ClsTyDef a = H.ClsTyDef () (a :: TypeEqn) :: ClassDecl
+pattern ClsDefSig a b = H.ClsDefSig () (a :: Name) (b :: Type) :: ClassDecl
+
+-- ** `H.InstDecl`
+type InstDecl = H.InstDecl ()
+pattern InsDecl a = H.InsDecl () (a :: Decl) :: InstDecl
+pattern InsType a b = H.InsType () (a :: Type) (b :: Type) :: InstDecl
+pattern InsData a b c d = H.InsData () (a :: DataOrNew) (b :: Type) (c :: [QualConDecl]) (d :: (Maybe Deriving)) :: InstDecl
+pattern InsGData a b c d e = H.InsGData () (a :: DataOrNew) (b :: Type) (c :: (Maybe Kind)) (d :: [GadtDecl]) (e :: (Maybe Deriving)) :: InstDecl
+
+-- ** `H.BangType`
+type BangType = H.BangType ()
+pattern BangedTy = H.BangedTy () :: BangType
+pattern LazyTy = H.LazyTy () :: BangType
+pattern NoStrictAnnot = H.NoStrictAnnot () :: BangType
+
+-- ** `H.Unpackedness`
+type Unpackedness = H.Unpackedness ()
+pattern Unpack = H.Unpack () :: Unpackedness
+pattern NoUnpack = H.NoUnpack () :: Unpackedness
+pattern NoUnpackPragma = H.NoUnpackPragma () :: Unpackedness
+
+-- ** `H.Rhs`
+type Rhs = H.Rhs ()
+pattern UnGuardedRhs a = H.UnGuardedRhs () (a :: Exp) :: Rhs
+pattern GuardedRhss a = H.GuardedRhss () (a :: [GuardedRhs]) :: Rhs
+
+-- ** `H.GuardedRhs`
+type GuardedRhs = H.GuardedRhs ()
+pattern GuardedRhs a b = H.GuardedRhs () (a :: [Stmt]) (b :: Exp) :: GuardedRhs
+
+-- ** `H.Type`
+type Type = H.Type ()
+pattern TyForall a b c = H.TyForall () (a :: (Maybe [TyVarBind])) (b :: (Maybe Context)) (c :: Type) :: Type
+pattern TyFun a b = H.TyFun () (a :: Type) (b :: Type) :: Type
+pattern TyTuple a b = H.TyTuple () (a :: Boxed) (b :: [Type]) :: Type
+pattern TyList a = H.TyList () (a :: Type) :: Type
+pattern TyParArray a = H.TyParArray () (a :: Type) :: Type
+pattern TyApp a b = H.TyApp () (a :: Type) (b :: Type) :: Type
+pattern TyVar a = H.TyVar () (a :: Name) :: Type
+pattern TyCon a = H.TyCon () (a :: QName) :: Type
+pattern TyParen a = H.TyParen () (a :: Type) :: Type
+pattern TyInfix a b c = H.TyInfix () (a :: Type) (b :: QName) (c :: Type) :: Type
+pattern TyKind a b = H.TyKind () (a :: Type) (b :: Kind) :: Type
+pattern TyPromoted a = H.TyPromoted () (a :: Promoted) :: Type
+pattern TyEquals a b = H.TyEquals () (a :: Type) (b :: Type) :: Type
+pattern TySplice a = H.TySplice () (a :: Splice) :: Type
+pattern TyBang a b c = H.TyBang () (a :: BangType) (b :: Unpackedness) (c :: Type) :: Type
+pattern TyWildCard a = H.TyWildCard () (a :: (Maybe Name)) :: Type
+pattern TyQuasiQuote a b = H.TyQuasiQuote () (a :: String) (b :: String) :: Type
+
+-- ** `H.Promoted`
+type Promoted = H.Promoted ()
+pattern PromotedInteger a b = H.PromotedInteger () (a :: Integer) (b :: String) :: Promoted
+pattern PromotedString a b = H.PromotedString () (a :: String) (b :: String) :: Promoted
+pattern PromotedCon a b = H.PromotedCon () (a :: Bool) (b :: QName) :: Promoted
+pattern PromotedList a b = H.PromotedList () (a :: Bool) (b :: [Type]) :: Promoted
+pattern PromotedTuple a = H.PromotedTuple () (a :: [Type]) :: Promoted
+pattern PromotedUnit = H.PromotedUnit () :: Promoted
+
+-- skipped: data Boxed
+
+-- ** `H.TyVarBind`
+type TyVarBind = H.TyVarBind ()
+pattern KindedVar a b = H.KindedVar () (a :: Name) (b :: Kind) :: TyVarBind
+pattern UnkindedVar a = H.UnkindedVar () (a :: Name) :: TyVarBind
+
+-- ** `H.Kind`
+type Kind = H.Kind ()
+pattern KindStar = H.KindStar () :: Kind
+pattern KindFn a b = H.KindFn () (a :: Kind) (b :: Kind) :: Kind
+pattern KindParen a = H.KindParen () (a :: Kind) :: Kind
+pattern KindVar a = H.KindVar () (a :: QName) :: Kind
+pattern KindApp a b = H.KindApp () (a :: Kind) (b :: Kind) :: Kind
+pattern KindTuple a = H.KindTuple () (a :: [Kind]) :: Kind
+pattern KindList a = H.KindList () (a :: Kind) :: Kind
+
+-- ** `H.FunDep`
+type FunDep = H.FunDep ()
+pattern FunDep a b = H.FunDep () (a :: [Name]) (b :: [Name]) :: FunDep
+
+-- ** `H.Context`
+type Context = H.Context ()
+pattern CxSingle a = H.CxSingle () (a :: Asst) :: Context
+pattern CxTuple a = H.CxTuple () (a :: [Asst]) :: Context
+pattern CxEmpty = H.CxEmpty () :: Context
+
+-- ** `H.Asst`
+type Asst = H.Asst ()
+pattern ClassA a b = H.ClassA () (a :: QName) (b :: [Type]) :: Asst
+pattern AppA a b = H.AppA () (a :: Name) (b :: [Type]) :: Asst
+pattern InfixA a b c = H.InfixA () (a :: Type) (b :: QName) (c :: Type) :: Asst
+pattern IParam a b = H.IParam () (a :: IPName) (b :: Type) :: Asst
+pattern EqualP a b = H.EqualP () (a :: Type) (b :: Type) :: Asst
+pattern ParenA a = H.ParenA () (a :: Asst) :: Asst
+pattern WildCardA a = H.WildCardA () (a :: (Maybe Name)) :: Asst
+
+-- ** `H.Literal`
+-- literals are extra redundant!
+type Literal = H.Literal ()
+
+pattern Char a <- H.Char () (a :: Char) _ :: Literal
+    where Char a = H.Char () a [a]
+pattern String a <- H.String () (a :: String) _ :: Literal
+    where String a = H.String () a a
+pattern Int a <- H.Int () (a :: Integer) _ :: Literal
+    where Int a = H.Int () a (show a)
+pattern Frac a <- H.Frac () (a :: Rational) _ :: Literal
+    where Frac a = H.Frac () a (show a)
+pattern PrimInt a <- H.PrimInt () (a :: Integer) _ :: Literal
+    where PrimInt a = H.PrimInt () a (show a)
+pattern PrimWord a <- H.PrimWord () (a :: Integer) _ :: Literal
+    where PrimWord a = H.PrimWord () a (show a)
+pattern PrimFloat a <- H.PrimFloat () (a :: Rational) _ :: Literal
+    where PrimFloat a = H.PrimFloat () a (show a)
+pattern PrimDouble a <- H.PrimDouble () (a :: Rational) _ :: Literal
+    where PrimDouble a = H.PrimDouble () a (show a)
+pattern PrimChar a <- H.PrimChar () (a :: Char) _ :: Literal
+    where PrimChar a = H.PrimChar () a (show a)
+pattern PrimString a <- H.PrimString () (a :: String) _ :: Literal
+    where PrimString a = H.PrimString () a (show a)
+
+-- ** `H.Sign`
+type Sign = H.Sign ()
+pattern Signless = H.Signless () :: Sign
+pattern Negative = H.Negative () :: Sign
+
+-- ** `H.Exp`
+type Exp = H.Exp ()
+pattern Var a = H.Var () (a :: QName) :: Exp
+pattern OverloadedLabel a = H.OverloadedLabel () (a :: String) :: Exp
+pattern IPVar a = H.IPVar () (a :: IPName) :: Exp
+pattern Con a = H.Con () (a :: QName) :: Exp
+pattern Lit a = H.Lit () (a :: Literal) :: Exp
+pattern InfixApp a b c = H.InfixApp () (a :: Exp) (b :: QOp) (c :: Exp) :: Exp
+pattern App a b = H.App () (a :: Exp) (b :: Exp) :: Exp
+pattern NegApp a = H.NegApp () (a :: Exp) :: Exp
+pattern Lambda a b = H.Lambda () (a :: [Pat]) (b :: Exp) :: Exp
+pattern Let a b = H.Let () (a :: Binds) (b :: Exp) :: Exp
+pattern If a b c = H.If () (a :: Exp) (b :: Exp) (c :: Exp) :: Exp
+pattern MultiIf a = H.MultiIf () (a :: [GuardedRhs]) :: Exp
+pattern Case a b = H.Case () (a :: Exp) (b :: [Alt]) :: Exp
+pattern Do a = H.Do () (a :: [Stmt]) :: Exp
+pattern MDo a = H.MDo () (a :: [Stmt]) :: Exp
+pattern Tuple a b = H.Tuple () (a :: Boxed) (b :: [Exp]) :: Exp
+pattern TupleSection a b = H.TupleSection () (a :: Boxed) (b :: [Maybe Exp]) :: Exp
+pattern List a = H.List () (a :: [Exp]) :: Exp
+pattern ParArray a = H.ParArray () (a :: [Exp]) :: Exp
+pattern Paren a = H.Paren () (a :: Exp) :: Exp
+pattern LeftSection a b = H.LeftSection () (a :: Exp) (b :: QOp) :: Exp
+pattern RightSection a b = H.RightSection () (a :: QOp) (b :: Exp) :: Exp
+pattern RecConstr a b = H.RecConstr () (a :: QName) (b :: [FieldUpdate]) :: Exp
+pattern RecUpdate a b = H.RecUpdate () (a :: Exp) (b :: [FieldUpdate]) :: Exp
+pattern EnumFrom a = H.EnumFrom () (a :: Exp) :: Exp
+pattern EnumFromTo a b = H.EnumFromTo () (a :: Exp) (b :: Exp) :: Exp
+pattern EnumFromThen a b = H.EnumFromThen () (a :: Exp) (b :: Exp) :: Exp
+pattern EnumFromThenTo a b c = H.EnumFromThenTo () (a :: Exp) (b :: Exp) (c :: Exp) :: Exp
+pattern ParArrayFromTo a b = H.ParArrayFromTo () (a :: Exp) (b :: Exp) :: Exp
+pattern ParArrayFromThenTo a b c = H.ParArrayFromThenTo () (a :: Exp) (b :: Exp) (c :: Exp) :: Exp
+pattern ListComp a b = H.ListComp () (a :: Exp) (b :: [QualStmt]) :: Exp
+pattern ParComp a b = H.ParComp () (a :: Exp) (b :: [[QualStmt]]) :: Exp
+pattern ParArrayComp a b = H.ParArrayComp () (a :: Exp) (b :: [[QualStmt]]) :: Exp
+pattern ExpTypeSig a b = H.ExpTypeSig () (a :: Exp) (b :: Type) :: Exp
+pattern VarQuote a = H.VarQuote () (a :: QName) :: Exp
+pattern TypQuote a = H.TypQuote () (a :: QName) :: Exp
+pattern BracketExp a = H.BracketExp () (a :: Bracket) :: Exp
+pattern SpliceExp a = H.SpliceExp () (a :: Splice) :: Exp
+pattern QuasiQuote a b = H.QuasiQuote () (a :: String) (b :: String) :: Exp
+pattern TypeApp a = H.TypeApp () (a :: Type) :: Exp
+pattern XTag a b c d = H.XTag () (a :: XName) (b :: [XAttr]) (c :: (Maybe Exp)) (d :: [Exp]) :: Exp
+pattern XETag a b c = H.XETag () (a :: XName) (b :: [XAttr]) (c :: (Maybe Exp)) :: Exp
+pattern XPcdata a = H.XPcdata () (a :: String) :: Exp
+pattern XExpTag a = H.XExpTag () (a :: Exp) :: Exp
+pattern XChildTag a = H.XChildTag () (a :: [Exp]) :: Exp
+pattern CorePragma a b = H.CorePragma () (a :: String) (b :: Exp) :: Exp
+pattern SCCPragma a b = H.SCCPragma () (a :: String) (b :: Exp) :: Exp
+pattern GenPragma a b c d = H.GenPragma () (a :: String) (b :: (Int, Int)) (c :: (Int, Int)) (d :: Exp) :: Exp
+pattern Proc a b = H.Proc () (a :: Pat) (b :: Exp) :: Exp
+pattern LeftArrApp a b = H.LeftArrApp () (a :: Exp) (b :: Exp) :: Exp
+pattern RightArrApp a b = H.RightArrApp () (a :: Exp) (b :: Exp) :: Exp
+pattern LeftArrHighApp a b = H.LeftArrHighApp () (a :: Exp) (b :: Exp) :: Exp
+pattern RightArrHighApp a b = H.RightArrHighApp () (a :: Exp) (b :: Exp) :: Exp
+pattern LCase a = H.LCase () (a :: [Alt]) :: Exp
+pattern ExprHole = H.ExprHole () :: Exp
+
+-- ** `H.XName`
+type XName = H.XName ()
+pattern XName a = H.XName () (a :: String) :: XName
+pattern XDomName a b = H.XDomName () (a :: String) (b :: String) :: XName
+
+-- ** `H.XAttr`
+type XAttr = H.XAttr ()
+pattern XAttr a b = H.XAttr () (a :: XName) (b :: Exp) :: XAttr
+
+-- ** `H.Bracket`
+type Bracket = H.Bracket ()
+pattern ExpBracket a = H.ExpBracket () (a :: Exp) :: Bracket
+pattern PatBracket a = H.PatBracket () (a :: Pat) :: Bracket
+pattern TypeBracket a = H.TypeBracket () (a :: Type) :: Bracket
+pattern DeclBracket a = H.DeclBracket () (a :: [Decl]) :: Bracket
+
+-- ** `H.Splice`
+type Splice = H.Splice ()
+pattern IdSplice a = H.IdSplice () (a :: String) :: Splice
+pattern ParenSplice a = H.ParenSplice () (a :: Exp) :: Splice
+
+-- ** `H.Safety`
+type Safety = H.Safety ()
+pattern PlayRisky = H.PlayRisky () :: Safety
+pattern PlaySafe a = H.PlaySafe () (a :: Bool) :: Safety
+pattern PlayInterruptible = H.PlayInterruptible () :: Safety
+
+-- ** `H.CallConv`
+type CallConv = H.CallConv ()
+pattern StdCall = H.StdCall () :: CallConv
+pattern CCall = H.CCall () :: CallConv
+pattern CPlusPlus = H.CPlusPlus () :: CallConv
+pattern DotNet = H.DotNet () :: CallConv
+pattern Jvm = H.Jvm () :: CallConv
+pattern Js = H.Js () :: CallConv
+pattern JavaScript = H.JavaScript () :: CallConv
+pattern CApi = H.CApi () :: CallConv
+
+-- ** `H.ModulePragma`
+type ModulePragma = H.ModulePragma ()
+pattern LanguagePragma a = H.LanguagePragma () (a :: [Name]) :: ModulePragma
+pattern OptionsPragma a b = H.OptionsPragma () (a :: (Maybe Tool)) (b :: String) :: ModulePragma
+pattern AnnModulePragma a = H.AnnModulePragma () (a :: Annotation) :: ModulePragma
+
+-- skipped: data Tool
+
+-- ** `H.Overlap`
+type Overlap = H.Overlap ()
+pattern NoOverlap = H.NoOverlap () :: Overlap
+pattern Overlap = H.Overlap () :: Overlap
+pattern Incoherent = H.Incoherent () :: Overlap
+
+-- ** `H.Activation`
+type Activation = H.Activation ()
+pattern ActiveFrom a = H.ActiveFrom () (a :: Int) :: Activation
+pattern ActiveUntil a = H.ActiveUntil () (a :: Int) :: Activation
+
+-- ** `H.Rule`
+type Rule = H.Rule ()
+pattern 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 RuleVar a = H.RuleVar () (a :: Name) :: RuleVar
+pattern TypedRuleVar a b = H.TypedRuleVar () (a :: Name) (b :: Type) :: RuleVar
+
+-- ** `H.WarningText`
+type WarningText = H.WarningText ()
+pattern DeprText a = H.DeprText () (a :: String) :: WarningText
+pattern WarnText a = H.WarnText () (a :: String) :: WarningText
+
+-- ** `H.Pat`
+type Pat = H.Pat ()
+pattern PVar a = H.PVar () (a :: Name) :: Pat
+pattern PLit a b = H.PLit () (a :: Sign) (b :: Literal) :: Pat
+pattern PNPlusK a b = H.PNPlusK () (a :: Name) (b :: Integer) :: Pat
+pattern PInfixApp a b c = H.PInfixApp () (a :: Pat) (b :: QName) (c :: Pat) :: Pat
+pattern PApp a b = H.PApp () (a :: QName) (b :: [Pat]) :: Pat
+pattern PTuple a b = H.PTuple () (a :: Boxed) (b :: [Pat]) :: Pat
+pattern PList a = H.PList () (a :: [Pat]) :: Pat
+pattern PParen a = H.PParen () (a :: Pat) :: Pat
+pattern PRec a b = H.PRec () (a :: QName) (b :: [PatField]) :: Pat
+pattern PAsPat a b = H.PAsPat () (a :: Name) (b :: Pat) :: Pat
+pattern PWildCard = H.PWildCard () :: Pat
+pattern PIrrPat a = H.PIrrPat () (a :: Pat) :: Pat
+pattern PatTypeSig a b = H.PatTypeSig () (a :: Pat) (b :: Type) :: Pat
+pattern PViewPat a b = H.PViewPat () (a :: Exp) (b :: Pat) :: Pat
+pattern PRPat a = H.PRPat () (a :: [RPat]) :: Pat
+pattern PXTag a b c d = H.PXTag () (a :: XName) (b :: [PXAttr]) (c :: (Maybe Pat)) (d :: [Pat]) :: Pat
+pattern PXETag a b c = H.PXETag () (a :: XName) (b :: [PXAttr]) (c :: (Maybe Pat)) :: Pat
+pattern PXPcdata a = H.PXPcdata () (a :: String) :: Pat
+pattern PXPatTag a = H.PXPatTag () (a :: Pat) :: Pat
+pattern PXRPats a = H.PXRPats () (a :: [RPat]) :: Pat
+pattern PQuasiQuote a b = H.PQuasiQuote () (a :: String) (b :: String) :: Pat
+pattern PBangPat a = H.PBangPat () (a :: Pat) :: Pat
+
+-- ** `H.PXAttr`
+type PXAttr = H.PXAttr ()
+pattern PXAttr a b = H.PXAttr () (a :: XName) (b :: Pat) :: PXAttr
+
+-- ** `H.RPatOp`
+type RPatOp = H.RPatOp ()
+pattern RPStar = H.RPStar () :: RPatOp
+pattern RPStarG = H.RPStarG () :: RPatOp
+pattern RPPlus = H.RPPlus () :: RPatOp
+pattern RPPlusG = H.RPPlusG () :: RPatOp
+pattern RPOpt = H.RPOpt () :: RPatOp
+pattern RPOptG = H.RPOptG () :: RPatOp
+
+-- ** `H.RPat`
+type RPat = H.RPat ()
+pattern RPOp a b = H.RPOp () (a :: RPat) (b :: RPatOp) :: RPat
+pattern RPEither a b = H.RPEither () (a :: RPat) (b :: RPat) :: RPat
+pattern RPSeq a = H.RPSeq () (a :: [RPat]) :: RPat
+pattern RPGuard a b = H.RPGuard () (a :: Pat) (b :: [Stmt]) :: RPat
+pattern RPCAs a b = H.RPCAs () (a :: Name) (b :: RPat) :: RPat
+pattern RPAs a b = H.RPAs () (a :: Name) (b :: RPat) :: RPat
+pattern RPParen a = H.RPParen () (a :: RPat) :: RPat
+pattern RPPat a = H.RPPat () (a :: Pat) :: RPat
+
+-- ** `H.PatField`
+type PatField = H.PatField ()
+pattern PFieldPat a b = H.PFieldPat () (a :: QName) (b :: Pat) :: PatField
+pattern PFieldPun a = H.PFieldPun () (a :: QName) :: PatField
+pattern PFieldWildcard = H.PFieldWildcard () :: PatField
+
+-- ** `H.Stmt`
+type Stmt = H.Stmt ()
+pattern Generator a b = H.Generator () (a :: Pat) (b :: Exp) :: Stmt
+pattern Qualifier a = H.Qualifier () (a :: Exp) :: Stmt
+pattern LetStmt a = H.LetStmt () (a :: Binds) :: Stmt
+pattern RecStmt a = H.RecStmt () (a :: [Stmt]) :: Stmt
+
+-- ** `H.QualStmt`
+type QualStmt = H.QualStmt ()
+pattern QualStmt a = H.QualStmt () (a :: Stmt) :: QualStmt
+pattern ThenTrans a = H.ThenTrans () (a :: Exp) :: QualStmt
+pattern ThenBy a b = H.ThenBy () (a :: Exp) (b :: Exp) :: QualStmt
+pattern GroupBy a = H.GroupBy () (a :: Exp) :: QualStmt
+pattern GroupUsing a = H.GroupUsing () (a :: Exp) :: QualStmt
+pattern GroupByUsing a b = H.GroupByUsing () (a :: Exp) (b :: Exp) :: QualStmt
+
+-- ** `H.FieldUpdate`
+type FieldUpdate = H.FieldUpdate ()
+pattern FieldUpdate a b = H.FieldUpdate () (a :: QName) (b :: Exp) :: FieldUpdate
+pattern FieldPun a = H.FieldPun () (a :: QName) :: FieldUpdate
+pattern FieldWildcard = H.FieldWildcard () :: FieldUpdate
+
+-- ** `H.Alt`
+type Alt = H.Alt ()
+pattern Alt a b c = H.Alt () (a :: Pat) (b :: Rhs) (c :: (Maybe Binds)) :: Alt
+
+-- * Functions
+
+prelude_mod, main_mod :: ModuleName
+prelude_mod = H.prelude_mod ()
+main_mod = H.main_mod ()
+
+main_name :: Name
+main_name = H.main_name ()
+
+unit_con_name :: QName
+unit_con_name = H.unit_con_name ()
+
+tuple_con_name :: Boxed -> Int -> QName
+tuple_con_name = H.tuple_con_name ()
+
+list_cons_name :: QName
+list_cons_name = H.list_cons_name ()
+
+unboxed_singleton_con_name :: QName
+unboxed_singleton_con_name = H.unboxed_singleton_con_name ()
+
+unit_con :: Exp
+unit_con = H.unit_con ()
+
+tuple_con :: Boxed -> Int -> Exp
+tuple_con = H.tuple_con ()
+
+unboxed_singleton_con :: Exp
+unboxed_singleton_con = H.unboxed_singleton_con ()
+
+as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: Name
+as_name = H.as_name ()
+qualified_name = H.qualified_name ()
+hiding_name = H.hiding_name ()
+minus_name = H.minus_name ()
+bang_name = H.bang_name ()
+dot_name = H.dot_name ()
+star_name = H.star_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 :: Name
+export_name = H.export_name ()
+safe_name = H.safe_name ()
+unsafe_name = H.unsafe_name ()
+interruptible_name = H.interruptible_name ()
+threadsafe_name = H.threadsafe_name ()
+stdcall_name = H.stdcall_name ()
+ccall_name = H.ccall_name ()
+cplusplus_name = H.cplusplus_name ()
+dotnet_name = H.dotnet_name ()
+jvm_name = H.jvm_name ()
+js_name = H.js_name ()
+javascript_name = H.javascript_name ()
+capi_name = H.capi_name ()
+forall_name = H.forall_name ()
+family_name = H.family_name ()
+role_name = H.role_name ()
+
+unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: QName
+unit_tycon_name = H.unit_tycon_name ()
+fun_tycon_name = H.fun_tycon_name ()
+list_tycon_name = H.list_tycon_name ()
+unboxed_singleton_tycon_name = H.unboxed_singleton_tycon_name ()
+
+tuple_tycon_name :: Boxed -> Int -> QName
+tuple_tycon_name = H.tuple_tycon_name ()
+
+unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: Type
+unit_tycon = H.unit_tycon ()
+fun_tycon = H.fun_tycon ()
+list_tycon = H.list_tycon ()
+unboxed_singleton_tycon = H.unboxed_singleton_tycon ()
+
+tuple_tycon :: Boxed -> Int -> Type
+tuple_tycon = H.tuple_tycon ()
+
+-- skipped: (=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
+
+-- skipped: class Annotated ast