haskell-src-exts-1.8.2: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printerContentsIndex
Language.Haskell.Exts.Annotated.Syntax
Portabilityportable
Stabilitystable
MaintainerNiklas Broberg, d00nibro@chalmers.se
Contents
Modules
Declarations
Type classes and instances
Data type declarations
Function bindings
Class Assertions and Contexts
Types
Expressions
Patterns
Literals
Variables, Constructors and Operators
Template Haskell
FFI
Pragmas
Builtin names
Modules
Main function of a program
Constructors
Special identifiers
Type constructors
Source coordinates
Annotated trees
Description

A suite of datatypes describing the (semi-concrete) abstract syntax of Haskell 98 http://www.haskell.org/onlinereport/ plus registered extensions, including:

  • multi-parameter type classes with functional dependencies (MultiParamTypeClasses, FunctionalDependencies)
  • parameters of type class assertions are unrestricted (FlexibleContexts)
  • forall types as universal and existential quantification (RankNTypes, ExistentialQuantification, etc)
  • pattern guards (PatternGuards)
  • implicit parameters (ImplicitParameters)
  • generalised algebraic data types (GADTs)
  • template haskell (TemplateHaskell)
  • empty data type declarations (EmptyDataDecls)
  • unboxed tuples (UnboxedTuples)
  • regular patterns (RegularPatterns)
  • HSP-style XML expressions and patterns (XmlSyntax)

All nodes in the syntax tree are annotated with something of a user-definable data type. When parsing, this annotation will contain information about the source location that the particular node comes from.

Synopsis
data Module l
= Module l (Maybe (ModuleHead l)) [OptionPragma l] [ImportDecl l] [Decl l]
| XmlPage l (ModuleName l) [OptionPragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
| XmlHybrid l (Maybe (ModuleHead l)) [OptionPragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))
data WarningText l
= DeprText l String
| WarnText l String
data ExportSpecList l = ExportSpecList l [ExportSpec l]
data ExportSpec l
= EVar l (QName l)
| EAbs l (QName l)
| EThingAll l (QName l)
| EThingWith l (QName l) [CName l]
| EModuleContents l (ModuleName l)
data ImportDecl l = ImportDecl {
importAnn :: l
importModule :: ModuleName l
importQualified :: Bool
importSrc :: Bool
importPkg :: Maybe String
importAs :: Maybe (ModuleName l)
importSpecs :: Maybe (ImportSpecList l)
}
data ImportSpecList l = ImportSpecList l Bool [ImportSpec l]
data ImportSpec l
= IVar l (Name l)
| IAbs l (Name l)
| IThingAll l (Name l)
| IThingWith l (Name l) [CName l]
data Assoc l
= AssocNone l
| AssocLeft l
| AssocRight l
data Decl l
= TypeDecl l (DeclHead l) (Type l)
| TypeFamDecl l (DeclHead l) (Maybe (Kind l))
| DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] (Maybe (Deriving l))
| GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))
| DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))
| TypeInsDecl l (Type l) (Type l)
| DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))
| GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))
| ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])
| InstDecl l (Maybe (Context l)) (InstHead l) (Maybe [InstDecl l])
| DerivDecl l (Maybe (Context l)) (InstHead l)
| InfixDecl l (Assoc l) (Maybe Int) [Op l]
| DefaultDecl l [Type l]
| SpliceDecl l (Exp l)
| TypeSig l [Name l] (Type l)
| FunBind l [Match l]
| PatBind l (Pat l) (Maybe (Type l)) (Rhs l) (Maybe (Binds l))
| ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)
| ForExp l (CallConv l) (Maybe String) (Name l) (Type l)
| RulePragmaDecl l [Rule l]
| DeprPragmaDecl l [([Name l], String)]
| WarnPragmaDecl l [([Name l], String)]
| InlineSig l Bool (Maybe (Activation l)) (QName l)
| InlineConlikeSig l (Maybe (Activation l)) (QName l)
| SpecSig l (QName l) [Type l]
| SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]
| InstSig l (Maybe (Context l)) (InstHead l)
| AnnPragma l (Annotation l)
data DeclHead l
= DHead l (Name l) [TyVarBind l]
| DHInfix l (TyVarBind l) (Name l) (TyVarBind l)
| DHParen l (DeclHead l)
data InstHead l
= IHead l (QName l) [Type l]
| IHInfix l (Type l) (QName l) (Type l)
| IHParen l (InstHead l)
data Binds l
= BDecls l [Decl l]
| IPBinds l [IPBind l]
data IPBind l = IPBind l (IPName l) (Exp l)
data ClassDecl l
= ClsDecl l (Decl l)
| ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))
| ClsTyFam l (DeclHead l) (Maybe (Kind l))
| ClsTyDef l (Type l) (Type l)
data InstDecl l
= InsDecl l (Decl l)
| InsType l (Type l) (Type l)
| InsData l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))
| InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))
data Deriving l = Deriving l [InstHead l]
data DataOrNew l
= DataType l
| NewType l
data ConDecl l
= ConDecl l (Name l) [BangType l]
| InfixConDecl l (BangType l) (Name l) (BangType l)
| RecDecl l (Name l) [FieldDecl l]
data FieldDecl l = FieldDecl l [Name l] (BangType l)
data QualConDecl l = QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l)
data GadtDecl l = GadtDecl l (Name l) (Type l)
data BangType l
= BangedTy l (Type l)
| UnBangedTy l (Type l)
| UnpackedTy l (Type l)
data Match l
= Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
| InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
data Rhs l
= UnGuardedRhs l (Exp l)
| GuardedRhss l [GuardedRhs l]
data GuardedRhs l = GuardedRhs l [Stmt l] (Exp l)
data Context l
= CxSingle l (Asst l)
| CxTuple l [Asst l]
| CxParen l (Context l)
| CxEmpty l
data FunDep l = FunDep l [Name l] [Name l]
data Asst l
= ClassA l (QName l) [Type l]
| InfixA l (Type l) (QName l) (Type l)
| IParam l (IPName l) (Type l)
| EqualP l (Type l) (Type l)
data Type l
= TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)
| TyFun l (Type l) (Type l)
| TyTuple l Boxed [Type l]
| TyList l (Type l)
| TyApp l (Type l) (Type l)
| TyVar l (Name l)
| TyCon l (QName l)
| TyParen l (Type l)
| TyInfix l (Type l) (QName l) (Type l)
| TyKind l (Type l) (Kind l)
data Boxed
= Boxed
| Unboxed
data Kind l
= KindStar l
| KindBang l
| KindFn l (Kind l) (Kind l)
| KindParen l (Kind l)
| KindVar l (Name l)
data TyVarBind l
= KindedVar l (Name l) (Kind l)
| UnkindedVar l (Name l)
data Exp l
= Var l (QName l)
| IPVar l (IPName l)
| Con l (QName l)
| Lit l (Literal l)
| InfixApp l (Exp l) (QOp l) (Exp l)
| App l (Exp l) (Exp l)
| NegApp l (Exp l)
| Lambda l [Pat l] (Exp l)
| Let l (Binds l) (Exp l)
| If l (Exp l) (Exp l) (Exp l)
| Case l (Exp l) [Alt l]
| Do l [Stmt l]
| MDo l [Stmt l]
| Tuple l [Exp l]
| TupleSection l [Maybe (Exp l)]
| List l [Exp l]
| Paren l (Exp l)
| LeftSection l (Exp l) (QOp l)
| RightSection l (QOp l) (Exp l)
| RecConstr l (QName l) [FieldUpdate l]
| RecUpdate l (Exp l) [FieldUpdate l]
| EnumFrom l (Exp l)
| EnumFromTo l (Exp l) (Exp l)
| EnumFromThen l (Exp l) (Exp l)
| EnumFromThenTo l (Exp l) (Exp l) (Exp l)
| ListComp l (Exp l) [QualStmt l]
| ParComp l (Exp l) [[QualStmt l]]
| ExpTypeSig l (Exp l) (Type l)
| VarQuote l (QName l)
| TypQuote l (QName l)
| BracketExp l (Bracket l)
| SpliceExp l (Splice l)
| QuasiQuote l String String
| XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]
| XETag l (XName l) [XAttr l] (Maybe (Exp l))
| XPcdata l String
| XExpTag l (Exp l)
| CorePragma l String (Exp l)
| SCCPragma l String (Exp l)
| GenPragma l String (Int, Int) (Int, Int) (Exp l)
| Proc l (Pat l) (Exp l)
| LeftArrApp l (Exp l) (Exp l)
| RightArrApp l (Exp l) (Exp l)
| LeftArrHighApp l (Exp l) (Exp l)
| RightArrHighApp l (Exp l) (Exp l)
data Stmt l
= Generator l (Pat l) (Exp l)
| Qualifier l (Exp l)
| LetStmt l (Binds l)
| RecStmt l [Stmt l]
data QualStmt l
= QualStmt l (Stmt l)
| ThenTrans l (Exp l)
| ThenBy l (Exp l) (Exp l)
| GroupBy l (Exp l)
| GroupUsing l (Exp l)
| GroupByUsing l (Exp l) (Exp l)
data FieldUpdate l
= FieldUpdate l (QName l) (Exp l)
| FieldPun l (Name l)
| FieldWildcard l
data Alt l = Alt l (Pat l) (GuardedAlts l) (Maybe (Binds l))
data GuardedAlts l
= UnGuardedAlt l (Exp l)
| GuardedAlts l [GuardedAlt l]
data GuardedAlt l = GuardedAlt l [Stmt l] (Exp l)
data XAttr l = XAttr l (XName l) (Exp l)
data Pat l
= PVar l (Name l)
| PLit l (Literal l)
| PNeg l (Pat l)
| PNPlusK l (Name l) Integer
| PInfixApp l (Pat l) (QName l) (Pat l)
| PApp l (QName l) [Pat l]
| PTuple l [Pat l]
| PList l [Pat l]
| PParen l (Pat l)
| PRec l (QName l) [PatField l]
| PAsPat l (Name l) (Pat l)
| PWildCard l
| PIrrPat l (Pat l)
| PatTypeSig l (Pat l) (Type l)
| PViewPat l (Exp l) (Pat l)
| PRPat l [RPat l]
| PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]
| PXETag l (XName l) [PXAttr l] (Maybe (Pat l))
| PXPcdata l String
| PXPatTag l (Pat l)
| PXRPats l [RPat l]
| PExplTypeArg l (QName l) (Type l)
| PQuasiQuote l String String
| PBangPat l (Pat l)
data PatField l
= PFieldPat l (QName l) (Pat l)
| PFieldPun l (Name l)
| PFieldWildcard l
data PXAttr l = PXAttr l (XName l) (Pat l)
data RPat l
= RPOp l (RPat l) (RPatOp l)
| RPEither l (RPat l) (RPat l)
| RPSeq l [RPat l]
| RPGuard l (Pat l) [Stmt l]
| RPCAs l (Name l) (RPat l)
| RPAs l (Name l) (RPat l)
| RPParen l (RPat l)
| RPPat l (Pat l)
data RPatOp l
= RPStar l
| RPStarG l
| RPPlus l
| RPPlusG l
| RPOpt l
| RPOptG l
data Literal l
= Char l Char String
| String l String String
| Int l Integer String
| Frac l Rational String
| PrimInt l Integer String
| PrimWord l Integer String
| PrimFloat l Rational String
| PrimDouble l Rational String
| PrimChar l Char String
| PrimString l String String
data ModuleName l = ModuleName l String
data QName l
= Qual l (ModuleName l) (Name l)
| UnQual l (Name l)
| Special l (SpecialCon l)
data Name l
= Ident l String
| Symbol l String
data QOp l
= QVarOp l (QName l)
| QConOp l (QName l)
data Op l
= VarOp l (Name l)
| ConOp l (Name l)
data SpecialCon l
= UnitCon l
| ListCon l
| FunCon l
| TupleCon l Boxed Int
| Cons l
| UnboxedSingleCon l
data CName l
= VarName l (Name l)
| ConName l (Name l)
data IPName l
= IPDup l String
| IPLin l String
data XName l
= XName l String
| XDomName l String String
data Bracket l
= ExpBracket l (Exp l)
| PatBracket l (Pat l)
| TypeBracket l (Type l)
| DeclBracket l [Decl l]
data Splice l
= IdSplice l String
| ParenSplice l (Exp l)
data Safety l
= PlayRisky l
| PlaySafe l Bool
data CallConv l
= StdCall l
| CCall l
data OptionPragma l
= LanguagePragma l [Name l]
| OptionsPragma l (Maybe Tool) String
data Tool
= GHC
| HUGS
| NHC98
| YHC
| HADDOCK
| UnknownTool String
data Rule l = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)
data RuleVar l
= RuleVar l (Name l)
| TypedRuleVar l (Name l) (Type l)
data Activation l
= ActiveFrom l Int
| ActiveUntil l Int
data Annotation l
= Ann l (Name l) (Exp l)
| TypeAnn l (Name l) (Exp l)
| ModuleAnn l (Exp l)
prelude_mod :: l -> ModuleName l
main_mod :: l -> ModuleName l
main_name :: l -> Name l
unit_con_name :: l -> QName l
tuple_con_name :: l -> Boxed -> Int -> QName l
list_cons_name :: l -> QName l
unboxed_singleton_con_name :: l -> QName l
unit_con :: l -> Exp l
tuple_con :: l -> Boxed -> Int -> Exp l
unboxed_singleton_con :: l -> Exp l
as_name :: l -> Name l
qualified_name :: l -> Name l
hiding_name :: l -> Name l
minus_name :: l -> Name l
bang_name :: l -> Name l
dot_name :: l -> Name l
star_name :: l -> Name l
export_name :: l -> Name l
safe_name :: l -> Name l
unsafe_name :: l -> Name l
threadsafe_name :: l -> Name l
stdcall_name :: l -> Name l
ccall_name :: l -> Name l
unit_tycon_name :: l -> QName l
fun_tycon_name :: l -> QName l
list_tycon_name :: l -> QName l
tuple_tycon_name :: l -> Boxed -> Int -> QName l
unboxed_singleton_tycon_name :: l -> QName l
unit_tycon :: l -> Type l
fun_tycon :: l -> Type l
list_tycon :: l -> Type l
tuple_tycon :: l -> Boxed -> Int -> Type l
unboxed_singleton_tycon :: l -> Type l
class Functor ast => Annotated ast where
ann :: ast l -> l
amap :: (l -> l) -> ast l -> ast l
(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
Modules
data Module l
A complete Haskell source module.
Constructors
Module l (Maybe (ModuleHead l)) [OptionPragma l] [ImportDecl l] [Decl l]an ordinary Haskell module
XmlPage l (ModuleName l) [OptionPragma l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]a module consisting of a single XML document. The ModuleName never appears in the source but is needed for semantic purposes, it will be the same as the file name.
XmlHybrid l (Maybe (ModuleHead l)) [OptionPragma l] [ImportDecl l] [Decl l] (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]a hybrid module combining an XML document with an ordinary module
show/hide Instances
data ModuleHead l
The head of a module, including the name and export specification.
Constructors
ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l))
show/hide Instances
data WarningText l
Warning text to optionally use in the module header of e.g. a deprecated module.
Constructors
DeprText l String
WarnText l String
show/hide Instances
data ExportSpecList l
An explicit export specification.
Constructors
ExportSpecList l [ExportSpec l]
show/hide Instances
data ExportSpec l
An item in a module's export specification.
Constructors
EVar l (QName l)variable
EAbs l (QName l)T: a class or datatype exported abstractly, or a type synonym.
EThingAll l (QName l)T(..): a class exported with all of its methods, or a datatype exported with all of its constructors.
EThingWith l (QName l) [CName l]T(C_1,...,C_n): a class exported with some of its methods, or a datatype exported with some of its constructors.
EModuleContents l (ModuleName l)module M: re-export a module.
show/hide Instances
data ImportDecl l
An import declaration.
Constructors
ImportDecl
importAnn :: lannotation, used by parser for position of the import keyword.
importModule :: ModuleName lname of the module imported.
importQualified :: Boolimported qualified?
importSrc :: Boolimported with {-# SOURCE #-}?
importPkg :: Maybe Stringimported with explicit package name
importAs :: Maybe (ModuleName l)optional alias name in an as clause.
importSpecs :: Maybe (ImportSpecList l)optional list of import specifications.
show/hide Instances
data ImportSpecList l
An explicit import specification list.
Constructors
ImportSpecList l Bool [ImportSpec l]
show/hide Instances
data ImportSpec l
An import specification, representing a single explicit item imported (or hidden) from a module.
Constructors
IVar l (Name l)variable
IAbs l (Name l)T: the name of a class, datatype or type synonym.
IThingAll l (Name l)T(..): a class imported with all of its methods, or a datatype imported with all of its constructors.
IThingWith l (Name l) [CName l]T(C_1,...,C_n): a class imported with some of its methods, or a datatype imported with some of its constructors.
show/hide Instances
data Assoc l
Associativity of an operator.
Constructors
AssocNone lnon-associative operator (declared with infix)
AssocLeft lleft-associative operator (declared with infixl).
AssocRight lright-associative operator (declared with infixr)
show/hide Instances
Declarations
data Decl l
A top-level declaration.
Constructors
TypeDecl l (DeclHead l) (Type l)A type declaration
TypeFamDecl l (DeclHead l) (Maybe (Kind l))A type family declaration
DataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) [QualConDecl l] (Maybe (Deriving l))A data OR newtype declaration
GDataDecl l (DataOrNew l) (Maybe (Context l)) (DeclHead l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))A data OR newtype declaration, GADT style
DataFamDecl l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))A data family declaration
TypeInsDecl l (Type l) (Type l)A type family instance declaration
DataInsDecl l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))A data family instance declaration
GDataInsDecl l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))A data family instance declaration, GADT style
ClassDecl l (Maybe (Context l)) (DeclHead l) [FunDep l] (Maybe [ClassDecl l])A declaration of a type class
InstDecl l (Maybe (Context l)) (InstHead l) (Maybe [InstDecl l])An declaration of a type class instance
DerivDecl l (Maybe (Context l)) (InstHead l)A standalone deriving declaration
InfixDecl l (Assoc l) (Maybe Int) [Op l]A declaration of operator fixity
DefaultDecl l [Type l]A declaration of default types
SpliceDecl l (Exp l)A Template Haskell splicing declaration
TypeSig l [Name l] (Type l)A type signature declaration
FunBind l [Match l]A set of function binding clauses
PatBind l (Pat l) (Maybe (Type l)) (Rhs l) (Maybe (Binds l))A pattern binding
ForImp l (CallConv l) (Maybe (Safety l)) (Maybe String) (Name l) (Type l)A foreign import declaration
ForExp l (CallConv l) (Maybe String) (Name l) (Type l)A foreign export declaration
RulePragmaDecl l [Rule l]A RULES pragma
DeprPragmaDecl l [([Name l], String)]A DEPRECATED pragma
WarnPragmaDecl l [([Name l], String)]A WARNING pragma
InlineSig l Bool (Maybe (Activation l)) (QName l)An INLINE pragma
InlineConlikeSig l (Maybe (Activation l)) (QName l)An INLINE pragma
SpecSig l (QName l) [Type l]A SPECIALISE pragma
SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]A SPECIALISE INLINE pragma
InstSig l (Maybe (Context l)) (InstHead l)A SPECIALISE instance pragma
AnnPragma l (Annotation l)An ANN pragma
show/hide Instances
data DeclHead l
The head of a type or class declaration.
Constructors
DHead l (Name l) [TyVarBind l]
DHInfix l (TyVarBind l) (Name l) (TyVarBind l)
DHParen l (DeclHead l)
show/hide Instances
data InstHead l
The head of an instance declaration.
Constructors
IHead l (QName l) [Type l]
IHInfix l (Type l) (QName l) (Type l)
IHParen l (InstHead l)
show/hide Instances
data Binds l
A binding group inside a let or where clause.
Constructors
BDecls l [Decl l]An ordinary binding group
IPBinds l [IPBind l]A binding group for implicit parameters
show/hide Instances
data IPBind l
A binding of an implicit parameter.
Constructors
IPBind l (IPName l) (Exp l)
show/hide Instances
Type classes and instances
data ClassDecl l
Declarations inside a class declaration.
Constructors
ClsDecl l (Decl l)ordinary declaration
ClsDataFam l (Maybe (Context l)) (DeclHead l) (Maybe (Kind l))declaration of an associated data type
ClsTyFam l (DeclHead l) (Maybe (Kind l))declaration of an associated type synonym
ClsTyDef l (Type l) (Type l)default choice for an associated type synonym
show/hide Instances
data InstDecl l
Declarations inside an instance declaration.
Constructors
InsDecl l (Decl l)ordinary declaration
InsType l (Type l) (Type l)an associated type definition
InsData l (DataOrNew l) (Type l) [QualConDecl l] (Maybe (Deriving l))an associated data type implementation
InsGData l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))an associated data type implemented using GADT style
show/hide Instances
data Deriving l
A deriving clause following a data type declaration.
Constructors
Deriving l [InstHead l]
show/hide Instances
Data type declarations
data DataOrNew l
A flag stating whether a declaration is a data or newtype declaration.
Constructors
DataType l
NewType l
show/hide Instances
data ConDecl l
Declaration of an ordinary data constructor.
Constructors
ConDecl l (Name l) [BangType l]ordinary data constructor
InfixConDecl l (BangType l) (Name l) (BangType l)infix data constructor
RecDecl l (Name l) [FieldDecl l]record constructor
show/hide Instances
data FieldDecl l
Declaration of a (list of) named field(s).
Constructors
FieldDecl l [Name l] (BangType l)
show/hide Instances
data QualConDecl l
A single constructor declaration within a data type declaration, which may have an existential quantification binding.
Constructors
QualConDecl l (Maybe [TyVarBind l]) (Maybe (Context l)) (ConDecl l)
show/hide Instances
data GadtDecl l
A single constructor declaration in a GADT data type declaration.
Constructors
GadtDecl l (Name l) (Type l)
show/hide Instances
data BangType l
The type of a constructor argument or field, optionally including a strictness annotation.
Constructors
BangedTy l (Type l)strict component, marked with "!"
UnBangedTy l (Type l)non-strict component
UnpackedTy l (Type l)unboxed component, marked with an UNPACK pragma
show/hide Instances
Function bindings
data Match l
Clauses of a function binding.
Constructors
Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))A clause defined with prefix notation, i.e. the function name followed by its argument patterns, the right-hand side and an optional where clause.
InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) (Maybe (Binds l))A clause defined with infix notation, i.e. first its first argument pattern, then the function name, then its following argument(s), the right-hand side and an optional where clause. Note that there can be more than two arguments to a function declared infix, hence the list of pattern arguments.
show/hide Instances
data Rhs l
The right hand side of a function or pattern binding.
Constructors
UnGuardedRhs l (Exp l)unguarded right hand side (exp)
GuardedRhss l [GuardedRhs l]guarded right hand side (gdrhs)
show/hide Instances
data GuardedRhs l
A guarded right hand side | stmts = exp. The guard is a series of statements when using pattern guards, otherwise it will be a single qualifier expression.
Constructors
GuardedRhs l [Stmt l] (Exp l)
show/hide Instances
Class Assertions and Contexts
data Context l
A context is a set of assertions
Constructors
CxSingle l (Asst l)
CxTuple l [Asst l]
CxParen l (Context l)
CxEmpty l
show/hide Instances
data FunDep l
A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn
Constructors
FunDep l [Name l] [Name l]
show/hide Instances
data Asst l
Class assertions. In Haskell 98, the argument would be a tyvar, but this definition allows multiple parameters, and allows them to be types. Also extended with support for implicit parameters and equality constraints.
Constructors
ClassA l (QName l) [Type l]ordinary class assertion
InfixA l (Type l) (QName l) (Type l)class assertion where the class name is given infix
IParam l (IPName l) (Type l)implicit parameter assertion
EqualP l (Type l) (Type l)type equality constraint
show/hide Instances
Types
data Type l
A type qualified with a context. An unqualified type has an empty context.
Constructors
TyForall l (Maybe [TyVarBind l]) (Maybe (Context l)) (Type l)qualified type
TyFun l (Type l) (Type l)function type
TyTuple l Boxed [Type l]tuple type, possibly boxed
TyList l (Type l)list syntax, e.g. [a], as opposed to [] a
TyApp l (Type l) (Type l)application of a type constructor
TyVar l (Name l)type variable
TyCon l (QName l)named type or type constructor
TyParen l (Type l)type surrounded by parentheses
TyInfix l (Type l) (QName l) (Type l)infix type constructor
TyKind l (Type l) (Kind l)type with explicit kind signature
show/hide Instances
data Boxed
Flag denoting whether a tuple is boxed or unboxed.
Constructors
Boxed
Unboxed
show/hide Instances
data Kind l
An explicit kind annotation.
Constructors
KindStar l*, the kind of types
KindBang l!, the kind of unboxed types
KindFn l (Kind l) (Kind l)->, the kind of a type constructor
KindParen l (Kind l)a parenthesised kind
KindVar l (Name l)a kind variable (as-of-yet unsupported by compilers)
show/hide Instances
data TyVarBind l
A type variable declaration, optionally with an explicit kind annotation.
Constructors
KindedVar l (Name l) (Kind l)variable binding with kind annotation
UnkindedVar l (Name l)ordinary variable binding
show/hide Instances
Expressions
data Exp l
Haskell expressions.
Constructors
Var l (QName l)variable
IPVar l (IPName l)implicit parameter variable
Con l (QName l)data constructor
Lit l (Literal l)literal constant
InfixApp l (Exp l) (QOp l) (Exp l)infix application
App l (Exp l) (Exp l)ordinary application
NegApp l (Exp l)negation expression -exp (unary minus)
Lambda l [Pat l] (Exp l)lambda expression
Let l (Binds l) (Exp l)local declarations with let ... in ...
If l (Exp l) (Exp l) (Exp l)if exp then exp else exp
Case l (Exp l) [Alt l]case exp of alts
Do l [Stmt l]do-expression: the last statement in the list should be an expression.
MDo l [Stmt l]mdo-expression
Tuple l [Exp l]tuple expression
TupleSection l [Maybe (Exp l)]tuple section expression, e.g. (,,3)
List l [Exp l]list expression
Paren l (Exp l)parenthesised expression
LeftSection l (Exp l) (QOp l)left section (exp qop)
RightSection l (QOp l) (Exp l)right section (qop exp)
RecConstr l (QName l) [FieldUpdate l]record construction expression
RecUpdate l (Exp l) [FieldUpdate l]record update expression
EnumFrom l (Exp l)unbounded arithmetic sequence, incrementing by 1: [from ..]
EnumFromTo l (Exp l) (Exp l)bounded arithmetic sequence, incrementing by 1 [from .. to]
EnumFromThen l (Exp l) (Exp l)unbounded arithmetic sequence, with first two elements given [from, then ..]
EnumFromThenTo l (Exp l) (Exp l) (Exp l)bounded arithmetic sequence, with first two elements given [from, then .. to]
ListComp l (Exp l) [QualStmt l]ordinary list comprehension
ParComp l (Exp l) [[QualStmt l]]parallel list comprehension
ExpTypeSig l (Exp l) (Type l)expression with explicit type signature
VarQuote l (QName l)'x for template haskell reifying of expressions
TypQuote l (QName l)''T for template haskell reifying of types
BracketExp l (Bracket l)template haskell bracket expression
SpliceExp l (Splice l)template haskell splice expression
QuasiQuote l String Stringquasi-quotaion: [$name| string |]
XTag l (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]xml element, with attributes and children
XETag l (XName l) [XAttr l] (Maybe (Exp l))empty xml element, with attributes
XPcdata l StringPCDATA child element
XExpTag l (Exp l)escaped haskell expression inside xml
CorePragma l String (Exp l)CORE pragma
SCCPragma l String (Exp l)SCC pragma
GenPragma l String (Int, Int) (Int, Int) (Exp l)GENERATED pragma
Proc l (Pat l) (Exp l)arrows proc: proc pat -> exp
LeftArrApp l (Exp l) (Exp l)arrow application (from left): exp -< exp
RightArrApp l (Exp l) (Exp l)arrow application (from right): exp >- exp
LeftArrHighApp l (Exp l) (Exp l)higher-order arrow application (from left): exp -<< exp
RightArrHighApp l (Exp l) (Exp l)higher-order arrow application (from right): exp >>- exp
show/hide Instances
data Stmt l
A statement, representing both a stmt in a do-expression, an ordinary qual in a list comprehension, as well as a stmt in a pattern guard.
Constructors
Generator l (Pat l) (Exp l)a generator: pat <- exp
Qualifier l (Exp l)an exp by itself: in a do-expression, an action whose result is discarded; in a list comprehension and pattern guard, a guard expression
LetStmt l (Binds l)local bindings
RecStmt l [Stmt l]a recursive binding group for arrows
show/hide Instances
data QualStmt l
A general transqual in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.
Constructors
QualStmt l (Stmt l)an ordinary statement
ThenTrans l (Exp l)then exp
ThenBy l (Exp l) (Exp l)then exp by exp
GroupBy l (Exp l)then group by exp
GroupUsing l (Exp l)then group using exp
GroupByUsing l (Exp l) (Exp l)then group by exp using exp
show/hide Instances
data FieldUpdate l
An fbind in a labeled construction or update expression.
Constructors
FieldUpdate l (QName l) (Exp l)ordinary label-expresion pair
FieldPun l (Name l)record field pun
FieldWildcard lrecord field wildcard
show/hide Instances
data Alt l
An alt alternative in a case expression.
Constructors
Alt l (Pat l) (GuardedAlts l) (Maybe (Binds l))
show/hide Instances
data GuardedAlts l
The right-hand sides of a case alternative, which may be a single right-hand side or a set of guarded ones.
Constructors
UnGuardedAlt l (Exp l)-> exp
GuardedAlts l [GuardedAlt l]gdpat
show/hide Instances
data GuardedAlt l
A guarded case alternative | stmts -> exp.
Constructors
GuardedAlt l [Stmt l] (Exp l)
show/hide Instances
data XAttr l
An xml attribute, which is a name-expression pair.
Constructors
XAttr l (XName l) (Exp l)
show/hide Instances
Patterns
data Pat l
A pattern, to be matched against a value.
Constructors
PVar l (Name l)variable
PLit l (Literal l)literal constant
PNeg l (Pat l)negated pattern
PNPlusK l (Name l) Integern+k pattern
PInfixApp l (Pat l) (QName l) (Pat l)pattern with an infix data constructor
PApp l (QName l) [Pat l]data constructor and argument patterns
PTuple l [Pat l]tuple pattern
PList l [Pat l]list pattern
PParen l (Pat l)parenthesized pattern
PRec l (QName l) [PatField l]labelled pattern, record style
PAsPat l (Name l) (Pat l)@-pattern
PWildCard lwildcard pattern: _
PIrrPat l (Pat l)irrefutable pattern: ~pat
PatTypeSig l (Pat l) (Type l)pattern with type signature
PViewPat l (Exp l) (Pat l)view patterns of the form (exp -> pat)
PRPat l [RPat l]regular list pattern
PXTag l (XName l) [PXAttr l] (Maybe (Pat l)) [Pat l]XML element pattern
PXETag l (XName l) [PXAttr l] (Maybe (Pat l))XML singleton element pattern
PXPcdata l StringXML PCDATA pattern
PXPatTag l (Pat l)XML embedded pattern
PXRPats l [RPat l]XML regular list pattern
PExplTypeArg l (QName l) (Type l)Explicit generics style type argument e.g. f {| Int |} x = ...
PQuasiQuote l String Stringquasi quote pattern: [$name| string |]
PBangPat l (Pat l)strict (bang) pattern: f !x = ...
show/hide Instances
data PatField l
An fpat in a labeled record pattern.
Constructors
PFieldPat l (QName l) (Pat l)ordinary label-pattern pair
PFieldPun l (Name l)record field pun
PFieldWildcard lrecord field wildcard
show/hide Instances
data PXAttr l
An XML attribute in a pattern.
Constructors
PXAttr l (XName l) (Pat l)
show/hide Instances
data RPat l
An entity in a regular pattern.
Constructors
RPOp l (RPat l) (RPatOp l)operator pattern, e.g. pat*
RPEither l (RPat l) (RPat l)choice pattern, e.g. (1 | 2)
RPSeq l [RPat l]sequence pattern, e.g. (| 1, 2, 3 |)
RPGuard l (Pat l) [Stmt l]guarded pattern, e.g. (| p | p < 3 |)
RPCAs l (Name l) (RPat l)non-linear variable binding, e.g. (foo@:(1 | 2))*
RPAs l (Name l) (RPat l)linear variable binding, e.g. foo@(1 | 2)
RPParen l (RPat l)parenthesised pattern, e.g. (2*)
RPPat l (Pat l)an ordinary pattern
show/hide Instances
data RPatOp l
A regular pattern operator.
Constructors
RPStar l* = 0 or more
RPStarG l*! = 0 or more, greedy
RPPlus l+ = 1 or more
RPPlusG l+! = 1 or more, greedy
RPOpt l? = 0 or 1
RPOptG l?! = 0 or 1, greedy
show/hide Instances
Literals
data Literal l
literal Values of this type hold the abstract value of the literal, along with the precise string representation used. For example, 10, 0o12 and 0xa have the same value representation, but each carry a different string representation.
Constructors
Char l Char Stringcharacter literal
String l String Stringstring literal
Int l Integer Stringinteger literal
Frac l Rational Stringfloating point literal
PrimInt l Integer Stringunboxed integer literal
PrimWord l Integer Stringunboxed word literal
PrimFloat l Rational Stringunboxed float literal
PrimDouble l Rational Stringunboxed double literal
PrimChar l Char Stringunboxed character literal
PrimString l String Stringunboxed string literal
show/hide Instances
Variables, Constructors and Operators
data ModuleName l
The name of a Haskell module.
Constructors
ModuleName l String
show/hide Instances
data QName l
This type is used to represent qualified variables, and also qualified constructors.
Constructors
Qual l (ModuleName l) (Name l)name qualified with a module name
UnQual l (Name l)unqualified local name
Special l (SpecialCon l)built-in constructor with special syntax
show/hide Instances
data Name l
This type is used to represent variables, and also constructors.
Constructors
Ident l Stringvarid or conid.
Symbol l Stringvarsym or consym
show/hide Instances
data QOp l
Possibly qualified infix operators (qop), appearing in expressions.
Constructors
QVarOp l (QName l)variable operator (qvarop)
QConOp l (QName l)constructor operator (qconop)
show/hide Instances
data Op l
Operators appearing in infix declarations are never qualified.
Constructors
VarOp l (Name l)variable operator (varop)
ConOp l (Name l)constructor operator (conop)
show/hide Instances
data SpecialCon l
Constructors with special syntax. These names are never qualified, and always refer to builtin type or data constructors.
Constructors
UnitCon lunit type and data constructor ()
ListCon llist type constructor []
FunCon lfunction type constructor ->
TupleCon l Boxed Intn-ary tuple type and data constructors (,) etc, possibly boxed (#,#)
Cons llist data constructor (:)
UnboxedSingleCon lunboxed singleton tuple constructor (# #)
show/hide Instances
data CName l
A name (cname) of a component of a class or data type in an import or export specification.
Constructors
VarName l (Name l)name of a method or field
ConName l (Name l)name of a data constructor
show/hide Instances
data IPName l
An implicit parameter name.
Constructors
IPDup l String?ident, non-linear implicit parameter
IPLin l String%ident, linear implicit parameter
show/hide Instances
data XName l
The name of an xml element or attribute, possibly qualified with a namespace.
Constructors
XName l String
XDomName l String String
show/hide Instances
Template Haskell
data Bracket l
A template haskell bracket expression.
Constructors
ExpBracket l (Exp l)expression bracket: [| ... |]
PatBracket l (Pat l)pattern bracket: [p| ... |]
TypeBracket l (Type l)type bracket: [t| ... |]
DeclBracket l [Decl l]declaration bracket: [d| ... |]
show/hide Instances
data Splice l
A template haskell splice expression
Constructors
IdSplice l Stringvariable splice: $var
ParenSplice l (Exp l)parenthesised expression splice: $(exp)
show/hide Instances
FFI
data Safety l
The safety of a foreign function call.
Constructors
PlayRisky lunsafe
PlaySafe l Boolsafe (False) or threadsafe (True)
show/hide Instances
data CallConv l
The calling convention of a foreign function call.
Constructors
StdCall l
CCall l
show/hide Instances
Pragmas
data OptionPragma l
A top level options pragma, preceding the module header.
Constructors
LanguagePragma l [Name l]LANGUAGE pragma | IncludePragma l String -- ^ INCLUDE pragma | CFilesPragma l String -- ^ CFILES pragma
OptionsPragma l (Maybe Tool) StringOPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC
show/hide Instances
data Tool
Recognised tools for OPTIONS pragmas.
Constructors
GHC
HUGS
NHC98
YHC
HADDOCK
UnknownTool String
show/hide Instances
data Rule l
The body of a RULES pragma.
Constructors
Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l)
show/hide Instances
data RuleVar l
Variables used in a RULES pragma, optionally annotated with types
Constructors
RuleVar l (Name l)
TypedRuleVar l (Name l) (Type l)
show/hide Instances
data Activation l
Activation clause of a RULES pragma.
Constructors
ActiveFrom l Int
ActiveUntil l Int
show/hide Instances
data Annotation l
An annotation through an ANN pragma.
Constructors
Ann l (Name l) (Exp l)An annotation for a declared name.
TypeAnn l (Name l) (Exp l)An annotation for a declared type.
ModuleAnn l (Exp l)An annotation for the defining module.
show/hide Instances
Builtin names
Modules
prelude_mod :: l -> ModuleName l
main_mod :: l -> ModuleName l
Main function of a program
main_name :: l -> Name l
Constructors
unit_con_name :: l -> QName l
tuple_con_name :: l -> Boxed -> Int -> QName l
list_cons_name :: l -> QName l
unboxed_singleton_con_name :: l -> QName l
unit_con :: l -> Exp l
tuple_con :: l -> Boxed -> Int -> Exp l
unboxed_singleton_con :: l -> Exp l
Special identifiers
as_name :: l -> Name l
qualified_name :: l -> Name l
hiding_name :: l -> Name l
minus_name :: l -> Name l
bang_name :: l -> Name l
dot_name :: l -> Name l
star_name :: l -> Name l
export_name :: l -> Name l
safe_name :: l -> Name l
unsafe_name :: l -> Name l
threadsafe_name :: l -> Name l
stdcall_name :: l -> Name l
ccall_name :: l -> Name l
Type constructors
unit_tycon_name :: l -> QName l
fun_tycon_name :: l -> QName l
list_tycon_name :: l -> QName l
tuple_tycon_name :: l -> Boxed -> Int -> QName l
unboxed_singleton_tycon_name :: l -> QName l
unit_tycon :: l -> Type l
fun_tycon :: l -> Type l
list_tycon :: l -> Type l
tuple_tycon :: l -> Boxed -> Int -> Type l
unboxed_singleton_tycon :: l -> Type l
Source coordinates
Annotated trees
class Functor ast => Annotated ast where
AST nodes are annotated, and this class allows manipulation of the annotations.
Methods
ann :: ast l -> l
Retrieve the annotation of an AST node.
amap :: (l -> l) -> ast l -> ast l
Change the annotation of an AST node. Note that only the annotation of the node itself is affected, and not the annotations of any child nodes. if all nodes in the AST tree are to be affected, use fmap.
show/hide Instances
(=~=) :: (Annotated a, Eq (a ())) => a l1 -> a l2 -> Bool
Test if two AST elements are equal modulo annotations.
Produced by Haddock version 2.6.0