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


-- | Support for manipulating Haskell source code
--   
--   The <tt>haskell-src</tt> package provides support for manipulating
--   Haskell source code. The package provides a lexer, parser and
--   pretty-printer, and a definition of a Haskell abstract syntax tree
--   (AST). Common uses of this package are to parse or generate <a>Haskell
--   98</a> code.
@package haskell-src
@version 1.0.4


-- | A suite of datatypes describing the abstract syntax of <a>Haskell
--   98</a> plus a few extensions:
--   
--   <ul>
--   <li>multi-parameter type classes</li>
--   <li>parameters of type class assertions are unrestricted</li>
--   </ul>
--   
--   For GHC, we also derive <a>Typeable</a> and <a>Data</a> for all types.
module Language.Haskell.Syntax

-- | A Haskell source module.
data HsModule
HsModule :: SrcLoc -> Module -> Maybe [HsExportSpec] -> [HsImportDecl] -> [HsDecl] -> HsModule

-- | Export specification.
data HsExportSpec

-- | Variable.
HsEVar :: HsQName -> HsExportSpec

-- | <tt>T</tt>: A class or datatype exported abstractly, or a type
--   synonym.
HsEAbs :: HsQName -> HsExportSpec

-- | <tt>T(..)</tt>: A class exported with all of its methods, or a
--   datatype exported with all of its constructors.
HsEThingAll :: HsQName -> HsExportSpec

-- | <tt>T(C_1,...,C_n)</tt>: A class exported with some of its methods, or
--   a datatype exported with some of its constructors.
HsEThingWith :: HsQName -> [HsCName] -> HsExportSpec

-- | <tt>module M</tt>: Re-export a module.
HsEModuleContents :: Module -> HsExportSpec

-- | Import declaration.
data HsImportDecl
HsImportDecl :: SrcLoc -> Module -> Bool -> Maybe Module -> Maybe (Bool, [HsImportSpec]) -> HsImportDecl

-- | Position of the <tt>import</tt> keyword.
[importLoc] :: HsImportDecl -> SrcLoc

-- | Name of the module imported.
[importModule] :: HsImportDecl -> Module

-- | Imported <tt>qualified</tt>?
[importQualified] :: HsImportDecl -> Bool

-- | Optional alias name in an <tt>as</tt> clause.
[importAs] :: HsImportDecl -> Maybe Module

-- | Optional list of import specifications. The <a>Bool</a> is <a>True</a>
--   if the names are excluded by <tt>hiding</tt>.
[importSpecs] :: HsImportDecl -> Maybe (Bool, [HsImportSpec])

-- | Import specification.
data HsImportSpec

-- | Variable.
HsIVar :: HsName -> HsImportSpec

-- | <tt>T</tt>: The name of a class, datatype or type synonym.
HsIAbs :: HsName -> HsImportSpec

-- | <tt>T(..)</tt>: A class imported with all of its methods, or a
--   datatype imported with all of its constructors.
HsIThingAll :: HsName -> HsImportSpec

-- | <tt>T(C_1,...,C_n)</tt>: A class imported with some of its methods, or
--   a datatype imported with some of its constructors.
HsIThingWith :: HsName -> [HsCName] -> HsImportSpec

-- | Associativity of an operator.
data HsAssoc

-- | Non-associative operator (declared with <tt>infix</tt>).
HsAssocNone :: HsAssoc

-- | Left-associative operator (declared with <tt>infixl</tt>).
HsAssocLeft :: HsAssoc

-- | Right-associative operator (declared with <tt>infixr</tt>).
HsAssocRight :: HsAssoc
data HsDecl
HsTypeDecl :: SrcLoc -> HsName -> [HsName] -> HsType -> HsDecl
HsDataDecl :: SrcLoc -> HsContext -> HsName -> [HsName] -> [HsConDecl] -> [HsQName] -> HsDecl
HsInfixDecl :: SrcLoc -> HsAssoc -> Int -> [HsOp] -> HsDecl
HsNewTypeDecl :: SrcLoc -> HsContext -> HsName -> [HsName] -> HsConDecl -> [HsQName] -> HsDecl
HsClassDecl :: SrcLoc -> HsContext -> HsName -> [HsName] -> [HsDecl] -> HsDecl
HsInstDecl :: SrcLoc -> HsContext -> HsQName -> [HsType] -> [HsDecl] -> HsDecl
HsDefaultDecl :: SrcLoc -> [HsType] -> HsDecl
HsTypeSig :: SrcLoc -> [HsName] -> HsQualType -> HsDecl
HsFunBind :: [HsMatch] -> HsDecl
HsPatBind :: SrcLoc -> HsPat -> HsRhs -> [HsDecl] -> HsDecl
HsForeignImport :: SrcLoc -> String -> HsSafety -> String -> HsName -> HsType -> HsDecl
HsForeignExport :: SrcLoc -> String -> String -> HsName -> HsType -> HsDecl

-- | Declaration of a data constructor.
data HsConDecl

-- | Ordinary data constructor.
HsConDecl :: SrcLoc -> HsName -> [HsBangType] -> HsConDecl

-- | Record constructor.
HsRecDecl :: SrcLoc -> HsName -> [([HsName], HsBangType)] -> HsConDecl

-- | The type of a constructor argument or field, optionally including a
--   strictness annotation.
data HsBangType

-- | Strict component, marked with "<tt>!</tt>".
HsBangedTy :: HsType -> HsBangType

-- | Non-strict component.
HsUnBangedTy :: HsType -> HsBangType

-- | Clauses of a function binding.
data HsMatch
HsMatch :: SrcLoc -> HsName -> [HsPat] -> HsRhs -> [HsDecl] -> HsMatch

-- | The right hand side of a function or pattern binding.
data HsRhs

-- | Unguarded right hand side (<i>exp</i>).
HsUnGuardedRhs :: HsExp -> HsRhs

-- | Guarded right hand side (<i>gdrhs</i>).
HsGuardedRhss :: [HsGuardedRhs] -> HsRhs

-- | A guarded right hand side <tt>|</tt> <i>exp</i> <tt>=</tt> <i>exp</i>.
--   The first expression will be Boolean-valued.
data HsGuardedRhs
HsGuardedRhs :: SrcLoc -> HsExp -> HsExp -> HsGuardedRhs

-- | Safety level for invoking a foreign entity.
data HsSafety

-- | Call may generate callbacks.
HsSafe :: HsSafety

-- | Call will not generate callbacks.
HsUnsafe :: HsSafety

-- | A type qualified with a context. An unqualified type has an empty
--   context.
data HsQualType
HsQualType :: HsContext -> HsType -> HsQualType
type HsContext = [HsAsst]

-- | Class assertions. In Haskell 98, the argument would be a <i>tyvar</i>,
--   but this definition allows multiple parameters, and allows them to be
--   <i>type</i>s.
type HsAsst = (HsQName, [HsType])

-- | Haskell types and type constructors.
data HsType

-- | Function type.
HsTyFun :: HsType -> HsType -> HsType

-- | Tuple type.
HsTyTuple :: [HsType] -> HsType

-- | Application of a type constructor.
HsTyApp :: HsType -> HsType -> HsType

-- | Type variable.
HsTyVar :: HsName -> HsType

-- | Named type or type constructor.
HsTyCon :: HsQName -> HsType

-- | Haskell expressions.
--   
--   <i>Notes:</i>
--   
--   <ul>
--   <li>Because it is difficult for parsers to distinguish patterns from
--   expressions, they typically parse them in the same way and then check
--   that they have the appropriate form. Hence the expression type
--   includes some forms that are found only in patterns. After these
--   checks, these constructors should not be used.</li>
--   <li>The parser does not take precedence and associativity into
--   account, so it will leave <a>HsInfixApp</a>s associated to the
--   left.</li>
--   <li>The <a>Pretty</a> instance for <a>HsExp</a> does not add
--   parentheses in printing.</li>
--   </ul>
data HsExp

-- | Variable.
HsVar :: HsQName -> HsExp

-- | Data constructor.
HsCon :: HsQName -> HsExp

-- | Literal constant.
HsLit :: HsLiteral -> HsExp

-- | Infix application.
HsInfixApp :: HsExp -> HsQOp -> HsExp -> HsExp

-- | Ordinary application.
HsApp :: HsExp -> HsExp -> HsExp

-- | Negation expression <tt>-</tt> <i>exp</i>.
HsNegApp :: HsExp -> HsExp

-- | Lambda expression.
HsLambda :: SrcLoc -> [HsPat] -> HsExp -> HsExp

-- | Local declarations with <tt>let</tt>.
HsLet :: [HsDecl] -> HsExp -> HsExp

-- | <tt>If</tt> <i>exp</i> <tt>then</tt> <i>exp</i> <tt>else</tt>
--   <i>exp</i>.
HsIf :: HsExp -> HsExp -> HsExp -> HsExp

-- | <tt>Case</tt> <i>exp</i> <tt>of</tt> <i>alts</i>.
HsCase :: HsExp -> [HsAlt] -> HsExp

-- | <tt>Do</tt>-expression: The last statement in the list should be an
--   expression.
HsDo :: [HsStmt] -> HsExp

-- | Tuple expression.
HsTuple :: [HsExp] -> HsExp

-- | List expression.
HsList :: [HsExp] -> HsExp

-- | Parenthesized expression.
HsParen :: HsExp -> HsExp

-- | Left section <tt>(</tt><i>exp</i> <i>qop</i><tt>)</tt>.
HsLeftSection :: HsExp -> HsQOp -> HsExp

-- | Right section <tt>(</tt><i>qop</i> <i>exp</i><tt>)</tt>.
HsRightSection :: HsQOp -> HsExp -> HsExp

-- | Record construction expression.
HsRecConstr :: HsQName -> [HsFieldUpdate] -> HsExp

-- | Record update expression.
HsRecUpdate :: HsExp -> [HsFieldUpdate] -> HsExp

-- | Unbounded arithmetic sequence, incrementing by 1.
HsEnumFrom :: HsExp -> HsExp

-- | Bounded arithmetic sequence, incrementing by 1.
HsEnumFromTo :: HsExp -> HsExp -> HsExp

-- | Unbounded arithmetic sequence, with first two elements given.
HsEnumFromThen :: HsExp -> HsExp -> HsExp

-- | Bounded arithmetic sequence, with first two elements given.
HsEnumFromThenTo :: HsExp -> HsExp -> HsExp -> HsExp

-- | List comprehension.
HsListComp :: HsExp -> [HsStmt] -> HsExp

-- | Expression type signature.
HsExpTypeSig :: SrcLoc -> HsExp -> HsQualType -> HsExp

-- | (patterns only)
HsAsPat :: HsName -> HsExp -> HsExp

-- | (patterns only)
HsWildCard :: HsExp

-- | (patterns only)
HsIrrPat :: HsExp -> HsExp

-- | This type represents both <i>stmt</i> in a <tt>do</tt>-expression, and
--   <i>qual</i> in a list comprehension.
data HsStmt

-- | A generator <i>pat</i> <tt>&lt;-</tt> <i>exp</i>.
HsGenerator :: SrcLoc -> HsPat -> HsExp -> HsStmt

-- | An <i>exp</i> by itself: in a <tt>do</tt>-expression, an action whose
--   result is discarded; in a list comprehension, a guard expression.
HsQualifier :: HsExp -> HsStmt

-- | Local bindings.
HsLetStmt :: [HsDecl] -> HsStmt

-- | An <i>fbind</i> in a labeled record construction or update expression.
data HsFieldUpdate
HsFieldUpdate :: HsQName -> HsExp -> HsFieldUpdate

-- | An <i>alt</i> in a <tt>case</tt> expression.
data HsAlt
HsAlt :: SrcLoc -> HsPat -> HsGuardedAlts -> [HsDecl] -> HsAlt
data HsGuardedAlts

-- | <tt>-&gt;</tt> <i>exp</i>.
HsUnGuardedAlt :: HsExp -> HsGuardedAlts

-- | <i>gdpat</i>.
HsGuardedAlts :: [HsGuardedAlt] -> HsGuardedAlts

-- | A guarded alternative <tt>|</tt> <i>exp</i> <tt>-&gt;</tt> <i>exp</i>.
--   The first expression will be Boolean-valued.
data HsGuardedAlt
HsGuardedAlt :: SrcLoc -> HsExp -> HsExp -> HsGuardedAlt

-- | A pattern, to be matched against a value.
data HsPat

-- | Variable.
HsPVar :: HsName -> HsPat

-- | Literal constant.
HsPLit :: HsLiteral -> HsPat

-- | Negated pattern.
HsPNeg :: HsPat -> HsPat

-- | Pattern with infix data constructor.
HsPInfixApp :: HsPat -> HsQName -> HsPat -> HsPat

-- | Data constructor and argument patterns.
HsPApp :: HsQName -> [HsPat] -> HsPat

-- | Tuple pattern.
HsPTuple :: [HsPat] -> HsPat

-- | List pattern.
HsPList :: [HsPat] -> HsPat

-- | Parenthesized pattern.
HsPParen :: HsPat -> HsPat

-- | Labelled pattern.
HsPRec :: HsQName -> [HsPatField] -> HsPat

-- | <tt>@</tt>-Pattern.
HsPAsPat :: HsName -> HsPat -> HsPat

-- | Wildcard pattern (<tt>_</tt>).
HsPWildCard :: HsPat

-- | Irrefutable pattern (<tt>~</tt>).
HsPIrrPat :: HsPat -> HsPat

-- | An <i>fpat</i> in a labeled record pattern.
data HsPatField
HsPFieldPat :: HsQName -> HsPat -> HsPatField

-- | <i>literal</i>. Values of this type hold the abstract value of the
--   literal, not the precise string representation used. For example,
--   <tt>10</tt>, <tt>0o12</tt> and <tt>0xa</tt> have the same
--   representation.
data HsLiteral

-- | Character literal.
HsChar :: Char -> HsLiteral

-- | String literal.
HsString :: String -> HsLiteral

-- | Integer literal.
HsInt :: Integer -> HsLiteral

-- | Floating point literal.
HsFrac :: Rational -> HsLiteral

-- | GHC unboxed character literal.
HsCharPrim :: Char -> HsLiteral

-- | GHC unboxed string literal.
HsStringPrim :: String -> HsLiteral

-- | GHC unboxed integer literal.
HsIntPrim :: Integer -> HsLiteral

-- | GHC unboxed float literal.
HsFloatPrim :: Rational -> HsLiteral

-- | GHC unboxed double literal.
HsDoublePrim :: Rational -> HsLiteral

-- | The name of a Haskell module.
newtype Module
Module :: String -> Module

-- | This type is used to represent qualified variables, and also qualified
--   constructors.
data HsQName

-- | Name qualified with a module name.
Qual :: Module -> HsName -> HsQName

-- | Unqualified name.
UnQual :: HsName -> HsQName

-- | Built-in constructor with special syntax.
Special :: HsSpecialCon -> HsQName

-- | This type is used to represent variables, and also constructors.
data HsName

-- | <i>varid</i> or <i>conid</i>.
HsIdent :: String -> HsName

-- | <i>varsym</i> or <i>consym</i>.
HsSymbol :: String -> HsName

-- | Possibly qualified infix operators (<i>qop</i>), appearing in
--   expressions.
data HsQOp

-- | Variable operator (<i>qvarop</i>).
HsQVarOp :: HsQName -> HsQOp

-- | Constructor operator (<i>qconop</i>).
HsQConOp :: HsQName -> HsQOp

-- | Operators, appearing in <tt>infix</tt> declarations.
data HsOp

-- | Variable operator (<i>varop</i>).
HsVarOp :: HsName -> HsOp

-- | Constructor operator (<i>conop</i>).
HsConOp :: HsName -> HsOp

-- | Constructors with special syntax. These names are never qualified, and
--   always refer to builtin type or data constructors.
data HsSpecialCon

-- | Unit type and data constructor <tt>()</tt>.
HsUnitCon :: HsSpecialCon

-- | List type constructor <tt>[]</tt>.
HsListCon :: HsSpecialCon

-- | Function type constructor <tt>-&gt;</tt>.
HsFunCon :: HsSpecialCon

-- | <i>n</i>-ary tuple type and data constructors <tt>(,)</tt> etc.
HsTupleCon :: Int -> HsSpecialCon

-- | List data constructor <tt>(:)</tt>.
HsCons :: HsSpecialCon

-- | A name (<i>cname</i>) of a component of a class or data type in an
--   <tt>import</tt> or export specification.
data HsCName

-- | Name of a method or field.
HsVarName :: HsName -> HsCName

-- | Name of a data constructor.
HsConName :: HsName -> HsCName
prelude_mod :: Module
main_mod :: Module
main_name :: HsName
unit_con_name :: HsQName
tuple_con_name :: Int -> HsQName
list_cons_name :: HsQName
unit_con :: HsExp
tuple_con :: Int -> HsExp
unit_tycon_name :: HsQName
fun_tycon_name :: HsQName
list_tycon_name :: HsQName
tuple_tycon_name :: Int -> HsQName
unit_tycon :: HsType
fun_tycon :: HsType
list_tycon :: HsType
tuple_tycon :: Int -> HsType

-- | A position in the source.
data SrcLoc
SrcLoc :: String -> Int -> Int -> SrcLoc
[srcFilename] :: SrcLoc -> String
[srcLine] :: SrcLoc -> Int
[srcColumn] :: SrcLoc -> Int
instance Data.Data.Data Language.Haskell.Syntax.SrcLoc
instance GHC.Show.Show Language.Haskell.Syntax.SrcLoc
instance GHC.Classes.Ord Language.Haskell.Syntax.SrcLoc
instance GHC.Classes.Eq Language.Haskell.Syntax.SrcLoc
instance Data.Data.Data Language.Haskell.Syntax.Module
instance GHC.Show.Show Language.Haskell.Syntax.Module
instance GHC.Classes.Ord Language.Haskell.Syntax.Module
instance GHC.Classes.Eq Language.Haskell.Syntax.Module
instance Data.Data.Data Language.Haskell.Syntax.HsSpecialCon
instance GHC.Show.Show Language.Haskell.Syntax.HsSpecialCon
instance GHC.Classes.Ord Language.Haskell.Syntax.HsSpecialCon
instance GHC.Classes.Eq Language.Haskell.Syntax.HsSpecialCon
instance Data.Data.Data Language.Haskell.Syntax.HsName
instance GHC.Show.Show Language.Haskell.Syntax.HsName
instance GHC.Classes.Ord Language.Haskell.Syntax.HsName
instance GHC.Classes.Eq Language.Haskell.Syntax.HsName
instance Data.Data.Data Language.Haskell.Syntax.HsQName
instance GHC.Show.Show Language.Haskell.Syntax.HsQName
instance GHC.Classes.Ord Language.Haskell.Syntax.HsQName
instance GHC.Classes.Eq Language.Haskell.Syntax.HsQName
instance Data.Data.Data Language.Haskell.Syntax.HsQOp
instance GHC.Show.Show Language.Haskell.Syntax.HsQOp
instance GHC.Classes.Ord Language.Haskell.Syntax.HsQOp
instance GHC.Classes.Eq Language.Haskell.Syntax.HsQOp
instance Data.Data.Data Language.Haskell.Syntax.HsOp
instance GHC.Show.Show Language.Haskell.Syntax.HsOp
instance GHC.Classes.Ord Language.Haskell.Syntax.HsOp
instance GHC.Classes.Eq Language.Haskell.Syntax.HsOp
instance Data.Data.Data Language.Haskell.Syntax.HsCName
instance GHC.Show.Show Language.Haskell.Syntax.HsCName
instance GHC.Classes.Ord Language.Haskell.Syntax.HsCName
instance GHC.Classes.Eq Language.Haskell.Syntax.HsCName
instance Data.Data.Data Language.Haskell.Syntax.HsExportSpec
instance GHC.Show.Show Language.Haskell.Syntax.HsExportSpec
instance GHC.Classes.Eq Language.Haskell.Syntax.HsExportSpec
instance Data.Data.Data Language.Haskell.Syntax.HsImportSpec
instance GHC.Show.Show Language.Haskell.Syntax.HsImportSpec
instance GHC.Classes.Eq Language.Haskell.Syntax.HsImportSpec
instance Data.Data.Data Language.Haskell.Syntax.HsImportDecl
instance GHC.Show.Show Language.Haskell.Syntax.HsImportDecl
instance GHC.Classes.Eq Language.Haskell.Syntax.HsImportDecl
instance Data.Data.Data Language.Haskell.Syntax.HsAssoc
instance GHC.Show.Show Language.Haskell.Syntax.HsAssoc
instance GHC.Classes.Eq Language.Haskell.Syntax.HsAssoc
instance Data.Data.Data Language.Haskell.Syntax.HsSafety
instance GHC.Show.Show Language.Haskell.Syntax.HsSafety
instance GHC.Classes.Ord Language.Haskell.Syntax.HsSafety
instance GHC.Classes.Eq Language.Haskell.Syntax.HsSafety
instance Data.Data.Data Language.Haskell.Syntax.HsType
instance GHC.Show.Show Language.Haskell.Syntax.HsType
instance GHC.Classes.Eq Language.Haskell.Syntax.HsType
instance Data.Data.Data Language.Haskell.Syntax.HsBangType
instance GHC.Show.Show Language.Haskell.Syntax.HsBangType
instance GHC.Classes.Eq Language.Haskell.Syntax.HsBangType
instance Data.Data.Data Language.Haskell.Syntax.HsConDecl
instance GHC.Show.Show Language.Haskell.Syntax.HsConDecl
instance GHC.Classes.Eq Language.Haskell.Syntax.HsConDecl
instance Data.Data.Data Language.Haskell.Syntax.HsQualType
instance GHC.Show.Show Language.Haskell.Syntax.HsQualType
instance GHC.Classes.Eq Language.Haskell.Syntax.HsQualType
instance Data.Data.Data Language.Haskell.Syntax.HsLiteral
instance GHC.Show.Show Language.Haskell.Syntax.HsLiteral
instance GHC.Classes.Eq Language.Haskell.Syntax.HsLiteral
instance Data.Data.Data Language.Haskell.Syntax.HsPat
instance GHC.Show.Show Language.Haskell.Syntax.HsPat
instance GHC.Classes.Eq Language.Haskell.Syntax.HsPat
instance Data.Data.Data Language.Haskell.Syntax.HsPatField
instance GHC.Show.Show Language.Haskell.Syntax.HsPatField
instance GHC.Classes.Eq Language.Haskell.Syntax.HsPatField
instance Data.Data.Data Language.Haskell.Syntax.HsStmt
instance GHC.Show.Show Language.Haskell.Syntax.HsStmt
instance GHC.Classes.Eq Language.Haskell.Syntax.HsStmt
instance Data.Data.Data Language.Haskell.Syntax.HsFieldUpdate
instance GHC.Show.Show Language.Haskell.Syntax.HsFieldUpdate
instance GHC.Classes.Eq Language.Haskell.Syntax.HsFieldUpdate
instance Data.Data.Data Language.Haskell.Syntax.HsMatch
instance GHC.Show.Show Language.Haskell.Syntax.HsMatch
instance GHC.Classes.Eq Language.Haskell.Syntax.HsMatch
instance Data.Data.Data Language.Haskell.Syntax.HsGuardedRhs
instance GHC.Show.Show Language.Haskell.Syntax.HsGuardedRhs
instance GHC.Classes.Eq Language.Haskell.Syntax.HsGuardedRhs
instance Data.Data.Data Language.Haskell.Syntax.HsRhs
instance GHC.Show.Show Language.Haskell.Syntax.HsRhs
instance GHC.Classes.Eq Language.Haskell.Syntax.HsRhs
instance Data.Data.Data Language.Haskell.Syntax.HsDecl
instance GHC.Show.Show Language.Haskell.Syntax.HsDecl
instance GHC.Classes.Eq Language.Haskell.Syntax.HsDecl
instance Data.Data.Data Language.Haskell.Syntax.HsGuardedAlts
instance GHC.Show.Show Language.Haskell.Syntax.HsGuardedAlts
instance GHC.Classes.Eq Language.Haskell.Syntax.HsGuardedAlts
instance Data.Data.Data Language.Haskell.Syntax.HsAlt
instance GHC.Show.Show Language.Haskell.Syntax.HsAlt
instance GHC.Classes.Eq Language.Haskell.Syntax.HsAlt
instance Data.Data.Data Language.Haskell.Syntax.HsExp
instance GHC.Show.Show Language.Haskell.Syntax.HsExp
instance GHC.Classes.Eq Language.Haskell.Syntax.HsExp
instance Data.Data.Data Language.Haskell.Syntax.HsGuardedAlt
instance GHC.Show.Show Language.Haskell.Syntax.HsGuardedAlt
instance GHC.Classes.Eq Language.Haskell.Syntax.HsGuardedAlt
instance Data.Data.Data Language.Haskell.Syntax.HsModule
instance GHC.Show.Show Language.Haskell.Syntax.HsModule
instance GHC.Classes.Eq Language.Haskell.Syntax.HsModule


-- | Pretty printer for Haskell.
module Language.Haskell.Pretty

-- | Things that can be pretty-printed, including all the syntactic objects
--   in <a>Language.Haskell.Syntax</a>.
class Pretty a

-- | pretty-print with a given style and mode.
prettyPrintStyleMode :: Pretty a => Style -> PPHsMode -> a -> String

-- | pretty-print with the default style and a given mode.
prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String

-- | pretty-print with the default style and <a>defaultMode</a>.
prettyPrint :: Pretty a => a -> String

-- | A rendering style. Allows us to specify constraints to choose among
--   the many different rendering options.
data Style
Style :: Mode -> Int -> Float -> Style

-- | The rendering mode.
[mode] :: Style -> Mode

-- | Maximum length of a line, in characters.
[lineLength] :: Style -> Int

-- | Ratio of line length to ribbon length. A ribbon refers to the
--   characters on a line <i>excluding</i> indentation. So a
--   <a>lineLength</a> of 100, with a <a>ribbonsPerLine</a> of <tt>2.0</tt>
--   would only allow up to 50 characters of ribbon to be displayed on a
--   line, while allowing it to be indented up to 50 characters.
[ribbonsPerLine] :: Style -> Float

-- | The default style (<tt>mode=PageMode, lineLength=100,
--   ribbonsPerLine=1.5</tt>).
style :: Style

-- | Rendering mode.
data Mode

-- | Normal rendering (<a>lineLength</a> and <a>ribbonsPerLine</a>
--   respected').
PageMode :: Mode

-- | With zig-zag cuts.
ZigZagMode :: Mode

-- | No indentation, infinitely long lines (<a>lineLength</a> ignored), but
--   explicit new lines, i.e., <tt>text "one" $$ text "two"</tt>, are
--   respected.
LeftMode :: Mode

-- | All on one line, <a>lineLength</a> ignored and explicit new lines
--   (<tt>$$</tt>) are turned into spaces.
OneLineMode :: Mode

-- | Pretty-printing parameters.
--   
--   <i>Note:</i> the <a>onsideIndent</a> must be positive and less than
--   all other indents.
data PPHsMode
PPHsMode :: Indent -> Indent -> Indent -> Indent -> Indent -> Indent -> Bool -> PPLayout -> Bool -> Bool -> PPHsMode

-- | Indentation of a class or instance.
[classIndent] :: PPHsMode -> Indent

-- | Indentation of a <tt>do</tt>-expression.
[doIndent] :: PPHsMode -> Indent

-- | Indentation of the body of a <tt>case</tt> expression.
[caseIndent] :: PPHsMode -> Indent

-- | Indentation of the declarations in a <tt>let</tt> expression.
[letIndent] :: PPHsMode -> Indent

-- | Indentation of the declarations in a <tt>where</tt> clause.
[whereIndent] :: PPHsMode -> Indent

-- | Indentation added for continuation lines that would otherwise be
--   offside.
[onsideIndent] :: PPHsMode -> Indent

-- | Blank lines between statements?
[spacing] :: PPHsMode -> Bool

-- | Pretty-printing style to use.
[layout] :: PPHsMode -> PPLayout

-- | Add GHC-style <tt>LINE</tt> pragmas to output?
[linePragmas] :: PPHsMode -> Bool

-- | (not implemented yet)
[comments] :: PPHsMode -> Bool
type Indent = Int

-- | Varieties of layout we can use.
data PPLayout

-- | Classical layout.
PPOffsideRule :: PPLayout

-- | Classical layout made explicit.
PPSemiColon :: PPLayout

-- | Inline decls, with newlines between them.
PPInLine :: PPLayout

-- | Everything on a single line.
PPNoLayout :: PPLayout

-- | The default mode: pretty-print using the offside rule and sensible
--   defaults.
defaultMode :: PPHsMode
instance GHC.Classes.Eq Language.Haskell.Pretty.PPLayout
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsModule
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.Module
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsExportSpec
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsImportDecl
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsImportSpec
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsDecl
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsAssoc
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsSafety
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsMatch
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsConDecl
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsBangType
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQualType
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsType
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsRhs
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedRhs
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsLiteral
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsExp
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsPat
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsPatField
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsAlt
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedAlts
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsGuardedAlt
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsStmt
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsFieldUpdate
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQOp
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsQName
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsOp
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsName
instance Language.Haskell.Pretty.Pretty Language.Haskell.Syntax.HsCName
instance GHC.Base.Functor (Language.Haskell.Pretty.DocM s)
instance GHC.Base.Applicative (Language.Haskell.Pretty.DocM s)
instance GHC.Base.Monad (Language.Haskell.Pretty.DocM s)


-- | Monads for the Haskell parser and lexer.
module Language.Haskell.ParseMonad

-- | Monad for parsing
data P a

-- | 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
atSrcLoc :: P a -> SrcLoc -> P a
data LexContext
NoLayout :: LexContext
Layout :: Int -> LexContext

-- | Static parameters governing a parse. More to come later, e.g. literate
--   mode, language extensions.
data ParseMode
ParseMode :: String -> ParseMode

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

-- | Default parameters for a parse, currently just a marker for an unknown
--   filename.
defaultParseMode :: ParseMode
runParserWithMode :: ParseMode -> P a -> String -> ParseResult a
runParser :: P a -> String -> ParseResult a
getSrcLoc :: P SrcLoc
pushCurrentContext :: P ()
popContext :: P ()
data Lex r a
getInput :: Lex r String

-- | Discard some input characters (these must not include tabs or
--   newlines).
discard :: Int -> Lex r ()

-- | Discard the next character, which must be a newline.
lexNewline :: Lex a ()

-- | Discard the next character, which must be a tab.
lexTab :: Lex a ()
lexWhile :: (Char -> Bool) -> Lex a String
alternative :: Lex a v -> Lex a (Lex a v)
checkBOL :: Lex a Bool
setBOL :: Lex a ()
startToken :: Lex a ()
getOffside :: Lex a Ordering
pushContextL :: LexContext -> Lex a ()
popContextL :: String -> Lex a ()
instance GHC.Show.Show a => GHC.Show.Show (Language.Haskell.ParseMonad.ParseResult a)
instance GHC.Show.Show Language.Haskell.ParseMonad.LexContext
instance GHC.Classes.Ord Language.Haskell.ParseMonad.LexContext
instance GHC.Classes.Eq Language.Haskell.ParseMonad.LexContext
instance GHC.Show.Show a => GHC.Show.Show (Language.Haskell.ParseMonad.ParseStatus a)
instance GHC.Base.Functor (Language.Haskell.ParseMonad.Lex r)
instance GHC.Base.Applicative (Language.Haskell.ParseMonad.Lex r)
instance GHC.Base.Monad (Language.Haskell.ParseMonad.Lex r)
instance Control.Monad.Fail.MonadFail (Language.Haskell.ParseMonad.Lex r)
instance GHC.Base.Functor Language.Haskell.ParseMonad.P
instance GHC.Base.Applicative Language.Haskell.ParseMonad.P
instance GHC.Base.Monad Language.Haskell.ParseMonad.P
instance Control.Monad.Fail.MonadFail Language.Haskell.ParseMonad.P
instance GHC.Base.Functor Language.Haskell.ParseMonad.ParseResult
instance GHC.Base.Applicative Language.Haskell.ParseMonad.ParseResult
instance GHC.Base.Monad Language.Haskell.ParseMonad.ParseResult
instance GHC.Base.Monoid m => GHC.Base.Semigroup (Language.Haskell.ParseMonad.ParseResult m)
instance GHC.Base.Monoid m => GHC.Base.Monoid (Language.Haskell.ParseMonad.ParseResult m)


-- | Utilities for the Haskell parser.
module Language.Haskell.ParseUtils
splitTyConApp :: HsType -> P (HsName, [HsType])
mkRecConstrOrUpdate :: HsExp -> [HsFieldUpdate] -> P HsExp
checkPrec :: Integer -> P Int
checkContext :: HsType -> P HsContext
checkAssertion :: HsType -> P HsAsst
checkDataHeader :: HsQualType -> P (HsContext, HsName, [HsName])
checkClassHeader :: HsQualType -> P (HsContext, HsName, [HsName])
checkInstHeader :: HsQualType -> P (HsContext, HsQName, [HsType])
checkPattern :: HsExp -> P HsPat
checkExpr :: HsExp -> P HsExp
checkValDef :: SrcLoc -> HsExp -> HsRhs -> [HsDecl] -> P HsDecl
checkClassBody :: [HsDecl] -> P [HsDecl]
checkUnQual :: HsQName -> P HsName
checkRevDecls :: [HsDecl] -> P [HsDecl]


-- | Lexer for Haskell.
module Language.Haskell.Lexer
data Token
VarId :: String -> Token
QVarId :: (String, String) -> Token
ConId :: String -> Token
QConId :: (String, String) -> Token
VarSym :: String -> Token
ConSym :: String -> Token
QVarSym :: (String, String) -> Token
QConSym :: (String, String) -> Token
IntTok :: Integer -> Token
FloatTok :: Rational -> Token
Character :: Char -> Token
StringTok :: String -> Token
LeftParen :: Token
RightParen :: Token
SemiColon :: Token
LeftCurly :: Token
RightCurly :: Token
VRightCurly :: Token
LeftSquare :: Token
RightSquare :: Token
Comma :: Token
Underscore :: Token
BackQuote :: Token
DotDot :: Token
Colon :: Token
DoubleColon :: Token
Equals :: Token
Backslash :: Token
Bar :: Token
LeftArrow :: Token
RightArrow :: Token
At :: Token
Tilde :: Token
DoubleArrow :: Token
Minus :: Token
Exclamation :: Token
KW_Case :: Token
KW_Class :: Token
KW_Data :: Token
KW_Default :: Token
KW_Deriving :: Token
KW_Do :: Token
KW_Else :: Token
KW_Foreign :: Token
KW_If :: Token
KW_Import :: Token
KW_In :: Token
KW_Infix :: Token
KW_InfixL :: Token
KW_InfixR :: Token
KW_Instance :: Token
KW_Let :: Token
KW_Module :: Token
KW_NewType :: Token
KW_Of :: Token
KW_Then :: Token
KW_Type :: Token
KW_Where :: Token
KW_As :: Token
KW_Export :: Token
KW_Hiding :: Token
KW_Qualified :: Token
KW_Safe :: Token
KW_Unsafe :: Token
EOF :: Token
lexer :: (Token -> P a) -> P a
instance GHC.Show.Show Language.Haskell.Lexer.Token
instance GHC.Classes.Eq Language.Haskell.Lexer.Token


-- | Haskell parser.
module Language.Haskell.Parser

-- | Parse of a string, which should contain a complete Haskell 98 module.
parseModule :: String -> ParseResult HsModule

-- | Parse of a string, which should contain a complete Haskell 98 module.
parseModuleWithMode :: ParseMode -> String -> ParseResult HsModule

-- | Static parameters governing a parse. More to come later, e.g. literate
--   mode, language extensions.
data ParseMode
ParseMode :: String -> ParseMode

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

-- | Default parameters for a parse, currently just a marker for an unknown
--   filename.
defaultParseMode :: ParseMode

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