-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | A simplified view on the haskell-src-exts AST
--   
--   This package provides a shim for haskell-src-exts (HSE), exposing the
--   same AST but without annotations, using ghc's pattern synonyms.
--   
--   See README.md for further information and compatibility
--   considerations.
@package haskell-src-exts-simple
@version 1.23.1.0

-- | This module reexports Language.Haskell.Exts.Build.
module Language.Haskell.Exts.Simple.Build

-- | This module reexports Language.Haskell.Exts.Extension.
module Language.Haskell.Exts.Simple.Extension

-- | This module reexports Language.Haskell.Exts.Pretty.
module Language.Haskell.Exts.Simple.Pretty

-- | 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
pattern Int :: Integer -> Literal
pattern Char :: Char -> Literal
pattern List :: [Exp] -> Exp
pattern Symbol :: String -> Name
pattern TyCon :: QName -> Type
type Module = Module ()
pattern Module :: Maybe ModuleHead -> [ModulePragma] -> [ImportDecl] -> [Decl] -> Module
type Type = Type ()
pattern String :: String -> Literal
pattern If :: Exp -> Exp -> Exp -> Exp
pattern Ident :: String -> Name
type Alt = Alt ()
pattern Alt :: Pat -> Rhs -> Maybe Binds -> Alt
pattern Con :: QName -> Exp
pattern App :: Exp -> Exp -> Exp
pattern DataType :: DataOrNew
type Op = Op ()
type FieldUpdate = FieldUpdate ()
pattern FieldUpdate :: QName -> Exp -> FieldUpdate
pattern FieldPun :: QName -> FieldUpdate
pattern FieldWildcard :: FieldUpdate
type QualStmt = QualStmt ()
pattern QualStmt :: Stmt -> QualStmt
pattern ThenTrans :: Exp -> QualStmt
pattern ThenBy :: Exp -> Exp -> QualStmt
pattern GroupBy :: Exp -> QualStmt
pattern GroupUsing :: Exp -> QualStmt
pattern GroupByUsing :: Exp -> Exp -> QualStmt
type Stmt = Stmt ()
pattern Generator :: Pat -> Exp -> Stmt
pattern Qualifier :: Exp -> Stmt
pattern LetStmt :: Binds -> Stmt
pattern RecStmt :: [Stmt] -> Stmt
type PatField = PatField ()
pattern PFieldPat :: QName -> Pat -> PatField
pattern PFieldPun :: QName -> PatField
pattern PFieldWildcard :: PatField
type RPat = RPat ()
pattern RPOp :: RPat -> RPatOp -> RPat
pattern RPEither :: RPat -> RPat -> RPat
pattern RPSeq :: [RPat] -> RPat
pattern RPGuard :: Pat -> [Stmt] -> RPat
pattern RPCAs :: Name -> RPat -> RPat
pattern RPAs :: Name -> RPat -> RPat
pattern RPParen :: RPat -> RPat
pattern RPPat :: Pat -> RPat
type RPatOp = RPatOp ()
pattern RPStar :: RPatOp
pattern RPStarG :: RPatOp
pattern RPPlus :: RPatOp
pattern RPPlusG :: RPatOp
pattern RPOpt :: RPatOp
pattern RPOptG :: RPatOp
type PXAttr = PXAttr ()
pattern PXAttr :: XName -> Pat -> PXAttr
type Pat = Pat ()
pattern PVar :: Name -> Pat
pattern PLit :: Sign -> Literal -> Pat
pattern PNPlusK :: Name -> Integer -> Pat
pattern PInfixApp :: Pat -> QName -> Pat -> Pat
pattern PApp :: QName -> [Pat] -> Pat
pattern PTuple :: Boxed -> [Pat] -> Pat
pattern PUnboxedSum :: Int -> Int -> Pat -> Pat
pattern PList :: [Pat] -> Pat
pattern PParen :: Pat -> Pat
pattern PRec :: QName -> [PatField] -> Pat
pattern PAsPat :: Name -> Pat -> Pat
pattern PWildCard :: Pat
pattern PIrrPat :: Pat -> Pat
pattern PatTypeSig :: Pat -> Type -> Pat
pattern PViewPat :: Exp -> Pat -> Pat
pattern PRPat :: [RPat] -> Pat
pattern PXTag :: XName -> [PXAttr] -> Maybe Pat -> [Pat] -> Pat
pattern PXETag :: XName -> [PXAttr] -> Maybe Pat -> Pat
pattern PXPcdata :: String -> Pat
pattern PXPatTag :: Pat -> Pat
pattern PXRPats :: [RPat] -> Pat
pattern PSplice :: Splice -> Pat
pattern PQuasiQuote :: String -> String -> Pat
pattern PBangPat :: Pat -> Pat
type WarningText = WarningText ()
pattern DeprText :: String -> WarningText
pattern WarnText :: String -> WarningText
type RuleVar = RuleVar ()
pattern RuleVar :: Name -> RuleVar
pattern TypedRuleVar :: Name -> Type -> RuleVar
type Rule = Rule ()
pattern Rule :: String -> Maybe Activation -> Maybe [RuleVar] -> Exp -> Exp -> Rule
type Activation = Activation ()
pattern ActiveFrom :: Int -> Activation
pattern ActiveUntil :: Int -> Activation
type Overlap = Overlap ()
pattern Overlap :: Overlap
pattern NoOverlap :: Overlap
pattern Overlapping :: Overlap
pattern Overlaps :: Overlap
pattern Overlappable :: Overlap
pattern Incoherent :: Overlap
type ModulePragma = ModulePragma ()
pattern LanguagePragma :: [Name] -> ModulePragma
pattern OptionsPragma :: Maybe Tool -> String -> ModulePragma
pattern AnnModulePragma :: Annotation -> ModulePragma
type CallConv = CallConv ()
pattern StdCall :: CallConv
pattern CCall :: CallConv
pattern CPlusPlus :: CallConv
pattern DotNet :: CallConv
pattern Jvm :: CallConv
pattern Js :: CallConv
pattern JavaScript :: CallConv
pattern CApi :: CallConv
type Safety = Safety ()
pattern PlayRisky :: Safety
pattern PlaySafe :: Bool -> Safety
pattern PlayInterruptible :: Safety
type Splice = Splice ()
pattern IdSplice :: String -> Splice
pattern TIdSplice :: String -> Splice
pattern ParenSplice :: Exp -> Splice
pattern TParenSplice :: Exp -> Splice
type Bracket = Bracket ()
pattern ExpBracket :: Exp -> Bracket
pattern TExpBracket :: Exp -> Bracket
pattern PatBracket :: Pat -> Bracket
pattern TypeBracket :: Type -> Bracket
pattern DeclBracket :: [Decl] -> Bracket
type XAttr = XAttr ()
pattern XAttr :: XName -> Exp -> XAttr
type XName = XName ()
pattern XName :: String -> XName
pattern XDomName :: String -> String -> XName
type Exp = Exp ()
pattern Var :: QName -> Exp
pattern OverloadedLabel :: String -> Exp
pattern IPVar :: IPName -> Exp
pattern Lit :: Literal -> Exp
pattern InfixApp :: Exp -> QOp -> Exp -> Exp
pattern NegApp :: Exp -> Exp
pattern Lambda :: [Pat] -> Exp -> Exp
pattern Let :: Binds -> Exp -> Exp
pattern MultiIf :: [GuardedRhs] -> Exp
pattern Case :: Exp -> [Alt] -> Exp
pattern Do :: [Stmt] -> Exp
pattern MDo :: [Stmt] -> Exp
pattern Tuple :: Boxed -> [Exp] -> Exp
pattern UnboxedSum :: Int -> Int -> Exp -> Exp
pattern TupleSection :: Boxed -> [Maybe Exp] -> Exp
pattern ParArray :: [Exp] -> Exp
pattern Paren :: Exp -> Exp
pattern LeftSection :: Exp -> QOp -> Exp
pattern RightSection :: QOp -> Exp -> Exp
pattern RecConstr :: QName -> [FieldUpdate] -> Exp
pattern RecUpdate :: Exp -> [FieldUpdate] -> Exp
pattern EnumFrom :: Exp -> Exp
pattern EnumFromTo :: Exp -> Exp -> Exp
pattern EnumFromThen :: Exp -> Exp -> Exp
pattern EnumFromThenTo :: Exp -> Exp -> Exp -> Exp
pattern ParArrayFromTo :: Exp -> Exp -> Exp
pattern ParArrayFromThenTo :: Exp -> Exp -> Exp -> Exp
pattern ListComp :: Exp -> [QualStmt] -> Exp
pattern ParComp :: Exp -> [[QualStmt]] -> Exp
pattern ParArrayComp :: Exp -> [[QualStmt]] -> Exp
pattern ExpTypeSig :: Exp -> Type -> Exp
pattern VarQuote :: QName -> Exp
pattern TypQuote :: QName -> Exp
pattern BracketExp :: Bracket -> Exp
pattern SpliceExp :: Splice -> Exp
pattern QuasiQuote :: String -> String -> Exp
pattern TypeApp :: Type -> Exp
pattern XTag :: XName -> [XAttr] -> Maybe Exp -> [Exp] -> Exp
pattern XETag :: XName -> [XAttr] -> Maybe Exp -> Exp
pattern XPcdata :: String -> Exp
pattern XExpTag :: Exp -> Exp
pattern XChildTag :: [Exp] -> Exp
pattern CorePragma :: String -> Exp -> Exp
pattern SCCPragma :: String -> Exp -> Exp
pattern GenPragma :: String -> (Int, Int) -> (Int, Int) -> Exp -> Exp
pattern Proc :: Pat -> Exp -> Exp
pattern LeftArrApp :: Exp -> Exp -> Exp
pattern RightArrApp :: Exp -> Exp -> Exp
pattern LeftArrHighApp :: Exp -> Exp -> Exp
pattern RightArrHighApp :: Exp -> Exp -> Exp
pattern ArrOp :: Exp -> Exp
pattern LCase :: [Alt] -> Exp
type Sign = Sign ()
pattern Signless :: Sign
pattern Negative :: Sign
type Literal = Literal ()
pattern Frac :: Rational -> Literal
pattern PrimInt :: Integer -> Literal
pattern PrimWord :: Integer -> Literal
pattern PrimFloat :: Rational -> Literal
pattern PrimDouble :: Rational -> Literal
pattern PrimChar :: Char -> Literal
pattern PrimString :: String -> Literal
type Asst = Asst ()
pattern TypeA :: Type -> Asst
pattern IParam :: IPName -> Type -> Asst
pattern ParenA :: Asst -> Asst
type Context = Context ()
pattern CxSingle :: Asst -> Context
pattern CxTuple :: [Asst] -> Context
pattern CxEmpty :: Context
type FunDep = FunDep ()
pattern FunDep :: [Name] -> [Name] -> FunDep

-- | Note that Kind is an alias for Type since
--   haskell-src-exts-1.21.
type Kind = Kind ()
type TyVarBind = TyVarBind ()
pattern KindedVar :: Name -> Kind -> TyVarBind
pattern UnkindedVar :: Name -> TyVarBind
type Promoted = Promoted ()
pattern PromotedInteger :: Integer -> String -> Promoted
pattern PromotedString :: String -> String -> Promoted
pattern PromotedCon :: Bool -> QName -> Promoted
pattern PromotedList :: Bool -> [Type] -> Promoted
pattern PromotedTuple :: [Type] -> Promoted
pattern PromotedUnit :: Promoted
type MaybePromotedName = MaybePromotedName ()
pattern PromotedName :: QName -> MaybePromotedName
pattern UnpromotedName :: QName -> MaybePromotedName
pattern TyForall :: Maybe [TyVarBind] -> Maybe Context -> Type -> Type
pattern TyStar :: Type
pattern TyFun :: Type -> Type -> Type
pattern TyTuple :: Boxed -> [Type] -> Type
pattern TyUnboxedSum :: [Type] -> Type
pattern TyList :: Type -> Type
pattern TyParArray :: Type -> Type
pattern TyApp :: Type -> Type -> Type
pattern TyVar :: Name -> Type
pattern TyParen :: Type -> Type
pattern TyInfix :: Type -> MaybePromotedName -> Type -> Type
pattern TyKind :: Type -> Kind -> Type
pattern TyPromoted :: Promoted -> Type
pattern TyEquals :: Type -> Type -> Type
pattern TySplice :: Splice -> Type
pattern TyBang :: BangType -> Unpackedness -> Type -> Type
pattern TyWildCard :: Maybe Name -> Type
pattern TyQuasiQuote :: String -> String -> Type
type GuardedRhs = GuardedRhs ()
pattern GuardedRhs :: [Stmt] -> Exp -> GuardedRhs
type Rhs = Rhs ()
pattern UnGuardedRhs :: Exp -> Rhs
pattern GuardedRhss :: [GuardedRhs] -> Rhs
type Unpackedness = Unpackedness ()
pattern Unpack :: Unpackedness
pattern NoUnpack :: Unpackedness
pattern NoUnpackPragma :: Unpackedness
type BangType = BangType ()
pattern BangedTy :: BangType
pattern LazyTy :: BangType
pattern NoStrictAnnot :: BangType
type InstDecl = InstDecl ()
pattern InstDecl :: Maybe Overlap -> InstRule -> Maybe [InstDecl] -> Decl
pattern InsDecl :: Decl -> InstDecl
pattern InsType :: Type -> Type -> InstDecl
pattern InsData :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> InstDecl
pattern InsGData :: DataOrNew -> Type -> Maybe Kind -> [GadtDecl] -> [Deriving] -> InstDecl
type ClassDecl = ClassDecl ()
pattern ClassDecl :: Maybe Context -> DeclHead -> [FunDep] -> Maybe [ClassDecl] -> Decl
pattern ClsDecl :: Decl -> ClassDecl
pattern ClsDataFam :: Maybe Context -> DeclHead -> Maybe ResultSig -> ClassDecl
pattern ClsTyFam :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> ClassDecl
pattern ClsTyDef :: TypeEqn -> ClassDecl
pattern ClsDefSig :: Name -> Type -> ClassDecl
type GadtDecl = GadtDecl ()
pattern GadtDecl :: Name -> Maybe [TyVarBind] -> Maybe Context -> Maybe [FieldDecl] -> Type -> GadtDecl
type FieldDecl = FieldDecl ()
pattern FieldDecl :: [Name] -> Type -> FieldDecl
type ConDecl = ConDecl ()
pattern ConDecl :: Name -> [Type] -> ConDecl
pattern InfixConDecl :: Type -> Name -> Type -> ConDecl
pattern RecDecl :: Name -> [FieldDecl] -> ConDecl
type QualConDecl = QualConDecl ()
pattern QualConDecl :: Maybe [TyVarBind] -> Maybe Context -> ConDecl -> QualConDecl
type Match = Match ()
pattern Match :: Name -> [Pat] -> Rhs -> Maybe Binds -> Match
pattern InfixMatch :: Pat -> Name -> [Pat] -> Rhs -> Maybe Binds -> Match
type IPBind = IPBind ()
pattern IPBind :: IPName -> Exp -> IPBind
type Binds = Binds ()
pattern BDecls :: [Decl] -> Binds
pattern IPBinds :: [IPBind] -> Binds
type DerivStrategy = DerivStrategy ()
pattern DerivStock :: DerivStrategy
pattern DerivAnyclass :: DerivStrategy
pattern DerivNewtype :: DerivStrategy
pattern DerivVia :: Type -> DerivStrategy
type Deriving = Deriving ()
pattern Deriving :: Maybe DerivStrategy -> [InstRule] -> Deriving
type InstHead = InstHead ()
pattern IHCon :: QName -> InstHead
pattern IHInfix :: Type -> QName -> InstHead
pattern IHParen :: InstHead -> InstHead
pattern IHApp :: InstHead -> Type -> InstHead
type InstRule = InstRule ()
pattern IRule :: Maybe [TyVarBind] -> Maybe Context -> InstHead -> InstRule
pattern IParen :: InstRule -> InstRule
type DeclHead = DeclHead ()
pattern DHead :: Name -> DeclHead
pattern DHInfix :: TyVarBind -> Name -> DeclHead
pattern DHParen :: DeclHead -> DeclHead
pattern DHApp :: DeclHead -> TyVarBind -> DeclHead
type ResultSig = ResultSig ()
pattern KindSig :: Kind -> ResultSig
pattern TyVarSig :: TyVarBind -> ResultSig
type InjectivityInfo = InjectivityInfo ()
pattern InjectivityInfo :: Name -> [Name] -> InjectivityInfo
type DataOrNew = DataOrNew ()
pattern NewType :: DataOrNew
type Role = Role ()
pattern Nominal :: Role
pattern Representational :: Role
pattern Phantom :: Role
pattern RoleWildcard :: Role
type BooleanFormula = BooleanFormula ()
pattern VarFormula :: Name -> BooleanFormula
pattern AndFormula :: [BooleanFormula] -> BooleanFormula
pattern OrFormula :: [BooleanFormula] -> BooleanFormula
pattern ParenFormula :: BooleanFormula -> BooleanFormula
type Annotation = Annotation ()
pattern Ann :: Name -> Exp -> Annotation
pattern TypeAnn :: Name -> Exp -> Annotation
pattern ModuleAnn :: Exp -> Annotation
type TypeEqn = TypeEqn ()
pattern TypeEqn :: Type -> Type -> TypeEqn
type PatternSynDirection = PatternSynDirection ()
pattern Unidirectional :: PatternSynDirection
pattern ImplicitBidirectional :: PatternSynDirection
pattern ExplicitBidirectional :: [Decl] -> PatternSynDirection
type Decl = Decl ()
pattern TypeDecl :: DeclHead -> Type -> Decl
pattern TypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> Decl
pattern ClosedTypeFamDecl :: DeclHead -> Maybe ResultSig -> Maybe InjectivityInfo -> [TypeEqn] -> Decl
pattern DataDecl :: DataOrNew -> Maybe Context -> DeclHead -> [QualConDecl] -> [Deriving] -> Decl
pattern GDataDecl :: DataOrNew -> Maybe Context -> DeclHead -> Maybe Kind -> [GadtDecl] -> [Deriving] -> Decl
pattern DataFamDecl :: Maybe Context -> DeclHead -> Maybe ResultSig -> Decl
pattern TypeInsDecl :: Type -> Type -> Decl
pattern DataInsDecl :: DataOrNew -> Type -> [QualConDecl] -> [Deriving] -> Decl
pattern GDataInsDecl :: DataOrNew -> Type -> Maybe Kind -> [GadtDecl] -> [Deriving] -> Decl
pattern DerivDecl :: Maybe DerivStrategy -> Maybe Overlap -> InstRule -> Decl
pattern InfixDecl :: Assoc -> Maybe Int -> [Op] -> Decl
pattern DefaultDecl :: [Type] -> Decl
pattern SpliceDecl :: Exp -> Decl
pattern TSpliceDecl :: Exp -> Decl
pattern TypeSig :: [Name] -> Type -> Decl
pattern PatSynSig :: [Name] -> Maybe [TyVarBind] -> Maybe Context -> Maybe [TyVarBind] -> Maybe Context -> Type -> Decl
pattern FunBind :: [Match] -> Decl
pattern PatBind :: Pat -> Rhs -> Maybe Binds -> Decl
pattern PatSyn :: Pat -> Pat -> PatternSynDirection -> Decl
pattern ForImp :: CallConv -> Maybe Safety -> Maybe String -> Name -> Type -> Decl
pattern ForExp :: CallConv -> Maybe String -> Name -> Type -> Decl
pattern RulePragmaDecl :: [Rule] -> Decl
pattern DeprPragmaDecl :: [([Name], String)] -> Decl
pattern WarnPragmaDecl :: [([Name], String)] -> Decl
pattern InlineSig :: Bool -> Maybe Activation -> QName -> Decl
pattern InlineConlikeSig :: Maybe Activation -> QName -> Decl
pattern SpecSig :: Maybe Activation -> QName -> [Type] -> Decl
pattern SpecInlineSig :: Bool -> Maybe Activation -> QName -> [Type] -> Decl
pattern InstSig :: InstRule -> Decl
pattern AnnPragma :: Annotation -> Decl
pattern MinimalPragma :: Maybe BooleanFormula -> Decl
pattern RoleAnnotDecl :: QName -> [Role] -> Decl
pattern CompletePragma :: [Name] -> Maybe QName -> Decl
type Assoc = Assoc ()
pattern AssocNone :: Assoc
pattern AssocLeft :: Assoc
pattern AssocRight :: Assoc
type ImportSpec = ImportSpec ()
pattern IVar :: Name -> ImportSpec
pattern IAbs :: Namespace -> Name -> ImportSpec
pattern IThingAll :: Name -> ImportSpec
pattern IThingWith :: Name -> [CName] -> ImportSpec
type ImportSpecList = ImportSpecList ()
pattern ImportSpecList :: Bool -> [ImportSpec] -> ImportSpecList
type ImportDecl = ImportDecl ()
pattern ImportDecl :: ModuleName () -> Bool -> Bool -> Bool -> Maybe String -> Maybe (ModuleName ()) -> Maybe (ImportSpecList ()) -> ImportDecl
importSpecs :: ImportDecl -> Maybe (ImportSpecList ())
importAs :: ImportDecl -> Maybe (ModuleName ())
importPkg :: ImportDecl -> Maybe String
importSafe :: ImportDecl -> Bool
importSrc :: ImportDecl -> Bool
importQualified :: ImportDecl -> Bool
importModule :: ImportDecl -> ModuleName ()
type Namespace = Namespace ()
pattern NoNamespace :: Namespace
pattern TypeNamespace :: Namespace
pattern PatternNamespace :: Namespace
type EWildcard = EWildcard ()
pattern EWildcard :: Int -> EWildcard
pattern NoWildcard :: EWildcard
type ExportSpec = ExportSpec ()
pattern EVar :: QName -> ExportSpec
pattern EAbs :: Namespace -> QName -> ExportSpec
pattern EThingWith :: EWildcard -> QName -> [CName] -> ExportSpec
pattern EModuleContents :: ModuleName -> ExportSpec
type ExportSpecList = ExportSpecList ()
pattern ExportSpecList :: [ExportSpec] -> ExportSpecList
type ModuleHead = ModuleHead ()
pattern ModuleHead :: ModuleName -> Maybe WarningText -> Maybe ExportSpecList -> ModuleHead
pattern XmlPage :: ModuleName -> [ModulePragma] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> Module
pattern XmlHybrid :: Maybe ModuleHead -> [ModulePragma] -> [ImportDecl] -> [Decl] -> XName -> [XAttr] -> Maybe Exp -> [Exp] -> Module
type CName = CName ()
pattern VarName :: Name -> CName
pattern ConName :: Name -> CName
pattern VarOp :: Name -> Op
pattern ConOp :: Name -> Op
type QOp = QOp ()
pattern QVarOp :: QName -> QOp
pattern QConOp :: QName -> QOp
type IPName = IPName ()
pattern IPDup :: String -> IPName
pattern IPLin :: String -> IPName
type Name = Name ()
type QName = QName ()
pattern Qual :: ModuleName -> Name -> QName
pattern UnQual :: Name -> QName
pattern Special :: SpecialCon -> QName
type SpecialCon = SpecialCon ()
pattern UnitCon :: SpecialCon
pattern ListCon :: SpecialCon
pattern FunCon :: SpecialCon
pattern TupleCon :: Boxed -> Int -> SpecialCon
pattern Cons :: SpecialCon
pattern UnboxedSingleCon :: SpecialCon
pattern ExprHole :: SpecialCon
type ModuleName = ModuleName ()
pattern ModuleName :: String -> ModuleName
prelude_mod :: ModuleName
main_mod :: ModuleName
main_name :: Name
unit_con_name :: QName
tuple_con_name :: Boxed -> Int -> QName
list_con_name :: QName
list_cons_name :: QName
unboxed_singleton_con_name :: QName
unit_con :: Exp
tuple_con :: Boxed -> Int -> Exp
unboxed_singleton_con :: Exp
as_name :: Name
qualified_name :: Name
hiding_name :: Name
minus_name :: Name
bang_name :: Name
dot_name :: Name
star_name :: Name
hole_name :: QName
export_name :: Name
safe_name :: Name
unsafe_name :: Name
interruptible_name :: Name
threadsafe_name :: Name
stdcall_name :: Name
ccall_name :: Name
cplusplus_name :: Name
dotnet_name :: Name
jvm_name :: Name
js_name :: Name
javascript_name :: Name
capi_name :: Name
forall_name :: Name
family_name :: Name
role_name :: Name
stock_name :: Name
anyclass_name :: Name
via_name :: Name
unit_tycon_name :: QName
fun_tycon_name :: QName
list_tycon_name :: QName
unboxed_singleton_tycon_name :: QName
tuple_tycon_name :: Boxed -> Int -> QName
unit_tycon :: Type
fun_tycon :: Type
list_tycon :: Type
unboxed_singleton_tycon :: Type
tuple_tycon :: Boxed -> Int -> Type
charL :: Char -> Literal
stringL :: String -> Literal
intL :: Integer -> Literal
fracL :: Rational -> Literal
primIntL :: Integer -> Literal
primWordL :: Integer -> Literal
primFloatL :: Rational -> Literal
primDoubleL :: Rational -> Literal
primCharL :: Char -> Literal
primStringL :: String -> Literal

-- | Recognised tools for OPTIONS pragmas.
data Tool
GHC :: Tool
HUGS :: Tool
NHC98 :: Tool
YHC :: Tool
HADDOCK :: Tool
UnknownTool :: String -> Tool

-- | Flag denoting whether a tuple is boxed or unboxed.
data Boxed
Boxed :: Boxed
Unboxed :: Boxed

-- | This module partially reexports Language.Haskell.Exts.Parser
--   with adaptations.
module Language.Haskell.Exts.Simple.Parser
parse :: (Parseable (ast SrcSpanInfo), Functor ast) => String -> ParseResult (ast ())
parseWithMode :: (Parseable (ast SrcSpanInfo), Functor ast) => ParseMode -> String -> ParseResult (ast ())
parseWithComments :: (Parseable (ast SrcSpanInfo), Functor ast) => ParseMode -> String -> ParseResult (ast (), [Comment])
type ListOf = ListOf
pattern ListOf :: [a] -> ListOf a
type ModuleHeadAndImports = ModuleHeadAndImports ()
pattern ModuleHeadAndImports :: [ModulePragma] -> Maybe ModuleHead -> [ImportDecl] -> ModuleHeadAndImports ()
type PragmasAndModuleHead = PragmasAndModuleHead ()
pattern PragmasAndModuleHead :: [ModulePragma] -> Maybe ModuleHead -> PragmasAndModuleHead ()
type PragmasAndModuleName = PragmasAndModuleName ()
pattern PragmasAndModuleName :: [ModulePragma] -> Maybe ModuleName -> PragmasAndModuleName
parseModule :: String -> ParseResult Module
parseModuleWithMode :: ParseMode -> String -> ParseResult Module
parseModuleWithComments :: ParseMode -> String -> ParseResult (Module, [Comment])
parseExp :: String -> ParseResult Exp
parseExpWithMode :: ParseMode -> String -> ParseResult Exp
parseExpWithComments :: ParseMode -> String -> ParseResult (Exp, [Comment])
parsePat :: String -> ParseResult Pat
parsePatWithMode :: ParseMode -> String -> ParseResult Pat
parsePatWithComments :: ParseMode -> String -> ParseResult (Pat, [Comment])
parseDecl :: String -> ParseResult Decl
parseDeclWithMode :: ParseMode -> String -> ParseResult Decl
parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl, [Comment])
parseType :: String -> ParseResult Type
parseTypeWithMode :: ParseMode -> String -> ParseResult Type
parseTypeWithComments :: ParseMode -> String -> ParseResult (Type, [Comment])
parseStmt :: String -> ParseResult Stmt
parseStmtWithMode :: ParseMode -> String -> ParseResult Stmt
parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt, [Comment])
parseImportDecl :: String -> ParseResult ImportDecl
parseImportDeclWithMode :: ParseMode -> String -> ParseResult ImportDecl
parseImportDeclWithComments :: ParseMode -> String -> ParseResult (ImportDecl, [Comment])
getTopPragmas :: String -> ParseResult [ModulePragma]
listOf :: [a] -> ListOf a

-- | Static parameters governing a parse. Note that the various parse
--   functions in Language.Haskell.Exts.Parser never look at
--   LANGUAGE pragmas, regardless of what the
--   ignoreLanguagePragmas flag is set to. Only the various
--   parseFile functions in Language.Haskell.Exts will act
--   on it, when set to False.
data ParseMode
ParseMode :: String -> Language -> [Extension] -> Bool -> Bool -> Maybe [Fixity] -> Bool -> ParseMode

-- | original name of the file being parsed
[parseFilename] :: ParseMode -> String

-- | base language (e.g. Haskell98, Haskell2010)
[baseLanguage] :: ParseMode -> Language

-- | list of extensions enabled for parsing
[extensions] :: ParseMode -> [Extension]

-- | if True, the parser won't care about further extensions in
--   LANGUAGE pragmas in source files
[ignoreLanguagePragmas] :: ParseMode -> Bool

-- | if True, the parser won't read line position information from
--   LINE pragmas in source files
[ignoreLinePragmas] :: ParseMode -> Bool

-- | list of fixities to be aware of
[fixities] :: ParseMode -> Maybe [Fixity]

-- | Checks whether functions have a consistent arity
[ignoreFunctionArity] :: ParseMode -> Bool

-- | The result of a parse.
data ParseResult a

-- | The parse succeeded, yielding a value.
ParseOk :: a -> ParseResult a

-- | The parse failed at the specified source location, with an error
--   message.
ParseFailed :: SrcLoc -> String -> ParseResult a

-- | Class providing function for parsing at many different types.
--   
--   Note that for convenience of implementation, the default methods have
--   definitions equivalent to undefined. The minimal definition is
--   all of the visible methods.
class Parseable ast

-- | Retrieve the result of a successful parse, throwing an error if the
--   parse is actually not successful.
fromParseResult :: ParseResult a -> a

-- | Default parameters for a parse. The default is an unknown filename, no
--   extensions (i.e. Haskell 98), don't ignore LANGUAGE pragmas, do ignore
--   LINE pragmas, and be aware of fixities from the Prelude.
defaultParseMode :: ParseMode

-- | Instances of Parseable for NonGreedy a will only
--   consume the input until a is fully parsed. This means that
--   parse errors that come later in the input will be ignored. It's also
--   more efficient, as it's fully lazy in the remainder of the input:
--   
--   
--   >>> parse (unlines ("module A where" : "main =" : repeat "blah")) :: ParseResult PragmasAndModuleHead
--   ParseOk (NonGreedy {unNonGreedy = PragmasAndModuleHead [] (ModuleName "A",Nothing,Nothing)})
--   
--   
--   (this example uses the simplified AST)
newtype NonGreedy a
NonGreedy :: a -> NonGreedy a
[unNonGreedy] :: NonGreedy a -> a
unListOf :: ListOf a -> [a]

-- | This module partially reexports Language.Haskell.Exts.Fixity,
--   adapting applyFixityies.
module Language.Haskell.Exts.Simple.Fixity
applyFixities :: (AppFixity ast, Functor ast, MonadFail m) => [Fixity] -> ast () -> m (ast ())

-- | Operator fixities are represented by their associativity (left, right
--   or none) and their precedence (0-9).
data Fixity
Fixity :: Assoc () -> Int -> QName () -> Fixity

-- | All AST elements that may include expressions which in turn may need
--   fixity tweaking will be instances of this class.
class AppFixity (ast :: Type -> Type)

-- | All fixities defined in the Prelude.
preludeFixities :: [Fixity]

-- | All fixities defined in the base package.
--   
--   Note that the +++ operator appears in both Control.Arrows and
--   Text.ParserCombinators.ReadP. The listed precedence for +++
--   in this list is that of Control.Arrows.
baseFixities :: [Fixity]
infixr_ :: Int -> [String] -> [Fixity]
infixl_ :: Int -> [String] -> [Fixity]
infix_ :: Int -> [String] -> [Fixity]

-- | This module exports all relevant modules of the
--   haskell-src-exts-simple package.
--   
--   The most important module is
--   Language.Haskell.Exts.Simple.Syntax.
module Language.Haskell.Exts.Simple
parseFile :: FilePath -> IO (ParseResult Module)
parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult Module)
parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult Module)
parseFileContents :: String -> ParseResult Module
parseFileContentsWithExts :: [Extension] -> String -> ParseResult Module
parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module
