Language.Haskell.Exts.Annotated.Syntax

haskell-src-exts-1.3.5: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer

Language.Haskell.Exts.Annotated.Syntax

Portability	portable
Stability	stable
Maintainer	Niklas Broberg, d00nibro@chalmers.se

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 {

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

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)

| SpecSig l (QName l) [Type l]

| SpecInlineSig l Bool (Maybe (Activation l)) (QName l) [Type l]

| InstSig l (Maybe (Context l)) (InstHead 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))

| InsInline l Bool (Maybe (Activation l)) (QName l)

data Deriving l = Deriving l [InstHead l]

data DataOrNew 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)

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

data Kind 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)

| 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

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

| 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

| PlaySafe l Bool

data CallConv l

data OptionPragma l

= LanguagePragma l [Name l]

| IncludePragma l String

| CFilesPragma l String

| OptionsPragma l (Maybe Tool) String

data Tool

| 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

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

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

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

Typeable1 Module

Annotated Module

AppFixity Module

Eq l => Eq (Module l)

Data l => Data (Module l)

Ord l => Ord (Module l)

Show l => Show (Module l)

SrcInfo pos => Pretty (Module pos)

SrcInfo loc => Parseable (Module loc)

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

Functor ModuleHead

Typeable1 ModuleHead

Annotated ModuleHead

ExactP ModuleHead

Eq l => Eq (ModuleHead l)

Data l => Data (ModuleHead l)

Ord l => Ord (ModuleHead l)

Show l => Show (ModuleHead l)

Pretty (ModuleHead l)

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

Functor WarningText

Typeable1 WarningText

Annotated WarningText

ExactP WarningText

Eq l => Eq (WarningText l)

Data l => Data (WarningText l)

Ord l => Ord (WarningText l)

Show l => Show (WarningText l)

Pretty (WarningText l)

data ExportSpecList l

An explicit export specification.

Constructors

ExportSpecList l [ExportSpec l]

show/hide

Instances

Functor ExportSpecList

Typeable1 ExportSpecList

Annotated ExportSpecList

ExactP ExportSpecList

Eq l => Eq (ExportSpecList l)

Data l => Data (ExportSpecList l)

Ord l => Ord (ExportSpecList l)

Show l => Show (ExportSpecList l)

Pretty (ExportSpecList l)

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

Functor ExportSpec

Typeable1 ExportSpec

Annotated ExportSpec

ExactP ExportSpec

Eq l => Eq (ExportSpec l)

Data l => Data (ExportSpec l)

Ord l => Ord (ExportSpec l)

Show l => Show (ExportSpec l)

Pretty (ExportSpec l)

data ImportDecl l

An import declaration.

Constructors

ImportDecl

importAnn :: l	annotation, used by parser for position of the `import` keyword.
importModule :: ModuleName l	name of the module imported.
importQualified :: Bool	imported `qualified`?
importSrc :: Bool	imported with `{-# SOURCE #-}`?
importPkg :: Maybe String	imported 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

Functor ImportDecl

Typeable1 ImportDecl

Annotated ImportDecl

ExactP ImportDecl

Eq l => Eq (ImportDecl l)

Data l => Data (ImportDecl l)

Ord l => Ord (ImportDecl l)

Show l => Show (ImportDecl l)

SrcInfo pos => Pretty (ImportDecl pos)

data ImportSpecList l

An explicit import specification list.

Constructors

ImportSpecList l Bool [ImportSpec l]

show/hide

Instances

Functor ImportSpecList

Typeable1 ImportSpecList

Annotated ImportSpecList

ExactP ImportSpecList

Eq l => Eq (ImportSpecList l)

Data l => Data (ImportSpecList l)

Ord l => Ord (ImportSpecList l)

Show l => Show (ImportSpecList l)

Pretty (ImportSpecList l)

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

Functor ImportSpec

Typeable1 ImportSpec

Annotated ImportSpec

ExactP ImportSpec

Eq l => Eq (ImportSpec l)

Data l => Data (ImportSpec l)

Ord l => Ord (ImportSpec l)

Show l => Show (ImportSpec l)

Pretty (ImportSpec l)

data Assoc l

Associativity of an operator.

Constructors

AssocNone l	non-associative operator (declared with `infix`)
AssocLeft l	left-associative operator (declared with `infixl`).
AssocRight l	right-associative operator (declared with `infixr`)

show/hide

Instances

Typeable1 Assoc

Annotated Assoc

Eq l => Eq (Assoc l)

Data l => Data (Assoc l)

Ord l => Ord (Assoc l)

Show l => Show (Assoc l)

Pretty (Assoc l)

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

show/hide

Instances

Eq l => Eq (Decl l)

Data l => Data (Decl l)

Ord l => Ord (Decl l)

Show l => Show (Decl l)

SrcInfo pos => Pretty (Decl pos)

SrcInfo loc => Parseable (Decl loc)

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

Functor DeclHead

Typeable1 DeclHead

Annotated DeclHead

ExactP DeclHead

Eq l => Eq (DeclHead l)

Data l => Data (DeclHead l)

Ord l => Ord (DeclHead l)

Show l => Show (DeclHead l)

Pretty (DeclHead l)

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

Functor InstHead

Typeable1 InstHead

Annotated InstHead

ExactP InstHead

Eq l => Eq (InstHead l)

Data l => Data (InstHead l)

Ord l => Ord (InstHead l)

Show l => Show (InstHead l)

Pretty (InstHead l)

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

Typeable1 Binds

Annotated Binds

AppFixity Binds

Eq l => Eq (Binds l)

Data l => Data (Binds l)

Ord l => Ord (Binds l)

Show l => Show (Binds l)

data IPBind l

A binding of an implicit parameter.

Constructors

IPBind l (IPName l) (Exp l)

show/hide

Instances

Typeable1 IPBind

Annotated IPBind

AppFixity IPBind

Eq l => Eq (IPBind l)

Data l => Data (IPBind l)

Ord l => Ord (IPBind l)

Show l => Show (IPBind l)

SrcInfo loc => Pretty (IPBind loc)

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

Functor ClassDecl

Typeable1 ClassDecl

Annotated ClassDecl

ExactP ClassDecl

AppFixity ClassDecl

Eq l => Eq (ClassDecl l)

Data l => Data (ClassDecl l)

Ord l => Ord (ClassDecl l)

Show l => Show (ClassDecl l)

SrcInfo loc => Pretty (ClassDecl loc)

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
InsInline l Bool (Maybe (Activation l)) (QName l)	an INLINE pragma

show/hide

Instances

Functor InstDecl

Typeable1 InstDecl

Annotated InstDecl

ExactP InstDecl

AppFixity InstDecl

Eq l => Eq (InstDecl l)

Data l => Data (InstDecl l)

Ord l => Ord (InstDecl l)

Show l => Show (InstDecl l)

SrcInfo loc => Pretty (InstDecl loc)

data Deriving l

A deriving clause following a data type declaration.

Constructors

Deriving l [InstHead l]

show/hide

Instances

Functor Deriving

Typeable1 Deriving

Annotated Deriving

ExactP Deriving

Eq l => Eq (Deriving l)

Data l => Data (Deriving l)

Ord l => Ord (Deriving l)

Show l => Show (Deriving l)

Pretty (Deriving l)

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

Functor DataOrNew

Typeable1 DataOrNew

Annotated DataOrNew

ExactP DataOrNew

Eq l => Eq (DataOrNew l)

Data l => Data (DataOrNew l)

Ord l => Ord (DataOrNew l)

Show l => Show (DataOrNew l)

Pretty (DataOrNew l)

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

Functor ConDecl

Typeable1 ConDecl

Annotated ConDecl

Eq l => Eq (ConDecl l)

Data l => Data (ConDecl l)

Ord l => Ord (ConDecl l)

Show l => Show (ConDecl l)

Pretty (ConDecl l)

data FieldDecl l

Declaration of a (list of) named field(s).

Constructors

FieldDecl l [Name l] (BangType l)

show/hide

Instances

Functor FieldDecl

Typeable1 FieldDecl

Annotated FieldDecl

ExactP FieldDecl

Eq l => Eq (FieldDecl l)

Data l => Data (FieldDecl l)

Ord l => Ord (FieldDecl l)

Show l => Show (FieldDecl l)

Pretty (FieldDecl l)

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

Functor QualConDecl

Typeable1 QualConDecl

Annotated QualConDecl

ExactP QualConDecl

Eq l => Eq (QualConDecl l)

Data l => Data (QualConDecl l)

Ord l => Ord (QualConDecl l)

Show l => Show (QualConDecl l)

Pretty (QualConDecl l)

data GadtDecl l

A single constructor declaration in a GADT data type declaration.

Constructors

GadtDecl l (Name l) (Type l)

show/hide

Instances

Functor GadtDecl

Typeable1 GadtDecl

Annotated GadtDecl

ExactP GadtDecl

Eq l => Eq (GadtDecl l)

Data l => Data (GadtDecl l)

Ord l => Ord (GadtDecl l)

Show l => Show (GadtDecl l)

Pretty (GadtDecl l)

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

Functor BangType

Typeable1 BangType

Annotated BangType

ExactP BangType

Eq l => Eq (BangType l)

Data l => Data (BangType l)

Ord l => Ord (BangType l)

Show l => Show (BangType l)

Pretty (BangType l)

Function bindings

data Match l

Clauses of a function binding.

Constructors

Match l (Name l) [Pat l] (Rhs l) (Maybe (Binds l))
InfixMatch l (Pat l) (Name l) (Pat l) (Rhs l) (Maybe (Binds l))

show/hide

Instances

Typeable1 Match

Annotated Match

AppFixity Match

Eq l => Eq (Match l)

Data l => Data (Match l)

Ord l => Ord (Match l)

Show l => Show (Match l)

SrcInfo pos => Pretty (Match pos)

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

Eq l => Eq (Rhs l)

Data l => Data (Rhs l)

Ord l => Ord (Rhs l)

Show l => Show (Rhs l)

SrcInfo loc => Pretty (Rhs loc)

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

Functor GuardedRhs

Typeable1 GuardedRhs

Annotated GuardedRhs

ExactP GuardedRhs

AppFixity GuardedRhs

Eq l => Eq (GuardedRhs l)

Data l => Data (GuardedRhs l)

Ord l => Ord (GuardedRhs l)

Show l => Show (GuardedRhs l)

SrcInfo loc => Pretty (GuardedRhs loc)

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

Functor Context

Typeable1 Context

Annotated Context

Eq l => Eq (Context l)

Data l => Data (Context l)

Ord l => Ord (Context l)

Show l => Show (Context l)

Pretty (Context l)

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

Typeable1 FunDep

Annotated FunDep

Eq l => Eq (FunDep l)

Data l => Data (FunDep l)

Ord l => Ord (FunDep l)

Show l => Show (FunDep l)

Pretty (FunDep l)

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

Eq l => Eq (Asst l)

Data l => Data (Asst l)

Ord l => Ord (Asst l)

Show l => Show (Asst l)

Pretty (Asst l)

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

Eq l => Eq (Type l)

Data l => Data (Type l)

Ord l => Ord (Type l)

Show l => Show (Type l)

Pretty (Type l)

SrcInfo loc => Parseable (Type loc)

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

Eq l => Eq (Kind l)

Data l => Data (Kind l)

Ord l => Ord (Kind l)

Show l => Show (Kind l)

Pretty (Kind l)

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

Functor TyVarBind

Typeable1 TyVarBind

Annotated TyVarBind

ExactP TyVarBind

Eq l => Eq (TyVarBind l)

Data l => Data (TyVarBind l)

Ord l => Ord (TyVarBind l)

Show l => Show (TyVarBind l)

Pretty (TyVarBind l)

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 String	quasi-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 String	PCDATA 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

Eq l => Eq (Exp l)

Data l => Data (Exp l)

Ord l => Ord (Exp l)

Show l => Show (Exp l)

SrcInfo loc => Pretty (Exp loc)

SrcInfo loc => Parseable (Exp loc)

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

Eq l => Eq (Stmt l)

Data l => Data (Stmt l)

Ord l => Ord (Stmt l)

Show l => Show (Stmt l)

SrcInfo loc => Pretty (Stmt loc)

SrcInfo loc => Parseable (Stmt loc)

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

Functor QualStmt

Typeable1 QualStmt

Annotated QualStmt

ExactP QualStmt

AppFixity QualStmt

Eq l => Eq (QualStmt l)

Data l => Data (QualStmt l)

Ord l => Ord (QualStmt l)

Show l => Show (QualStmt l)

SrcInfo loc => Pretty (QualStmt loc)

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 l	record field wildcard

show/hide

Instances

Functor FieldUpdate

Typeable1 FieldUpdate

Annotated FieldUpdate

ExactP FieldUpdate

AppFixity FieldUpdate

Eq l => Eq (FieldUpdate l)

Data l => Data (FieldUpdate l)

Ord l => Ord (FieldUpdate l)

Show l => Show (FieldUpdate l)

SrcInfo loc => Pretty (FieldUpdate loc)

data Alt l

An alt alternative in a case expression.

Constructors

Alt l (Pat l) (GuardedAlts l) (Maybe (Binds l))

show/hide

Instances

Eq l => Eq (Alt l)

Data l => Data (Alt l)

Ord l => Ord (Alt l)

Show l => Show (Alt l)

SrcInfo loc => Pretty (Alt loc)

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

Functor GuardedAlts

Typeable1 GuardedAlts

Annotated GuardedAlts

ExactP GuardedAlts

AppFixity GuardedAlts

Eq l => Eq (GuardedAlts l)

Data l => Data (GuardedAlts l)

Ord l => Ord (GuardedAlts l)

Show l => Show (GuardedAlts l)

SrcInfo loc => Pretty (GuardedAlts loc)

data GuardedAlt l

A guarded case alternative | stmts -> exp.

Constructors

GuardedAlt l [Stmt l] (Exp l)

show/hide

Instances

Functor GuardedAlt

Typeable1 GuardedAlt

Annotated GuardedAlt

ExactP GuardedAlt

AppFixity GuardedAlt

Eq l => Eq (GuardedAlt l)

Data l => Data (GuardedAlt l)

Ord l => Ord (GuardedAlt l)

Show l => Show (GuardedAlt l)

SrcInfo loc => Pretty (GuardedAlt loc)

data XAttr l

An xml attribute, which is a name-expression pair.

Constructors

XAttr l (XName l) (Exp l)

show/hide

Instances

Typeable1 XAttr

Annotated XAttr

AppFixity XAttr

Eq l => Eq (XAttr l)

Data l => Data (XAttr l)

Ord l => Ord (XAttr l)

Show l => Show (XAttr l)

SrcInfo loc => Pretty (XAttr loc)

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) Integer	n+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 l	wildcard 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 String	XML 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 String	quasi quote pattern: `[$name\| string \|]`
PBangPat l (Pat l)	strict (bang) pattern: `f !x = ...`

show/hide

Instances

Eq l => Eq (Pat l)

Data l => Data (Pat l)

Ord l => Ord (Pat l)

Show l => Show (Pat l)

SrcInfo loc => Pretty (Pat loc)

SrcInfo loc => Parseable (Pat loc)

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 l	record field wildcard

show/hide

Instances

Functor PatField

Typeable1 PatField

Annotated PatField

ExactP PatField

AppFixity PatField

Eq l => Eq (PatField l)

Data l => Data (PatField l)

Ord l => Ord (PatField l)

Show l => Show (PatField l)

SrcInfo loc => Pretty (PatField loc)

data PXAttr l

An XML attribute in a pattern.

Constructors

PXAttr l (XName l) (Pat l)

show/hide

Instances

Typeable1 PXAttr

Annotated PXAttr

AppFixity PXAttr

Eq l => Eq (PXAttr l)

Data l => Data (PXAttr l)

Ord l => Ord (PXAttr l)

Show l => Show (PXAttr l)

SrcInfo loc => Pretty (PXAttr loc)

data RPat l

An entity in a regular pattern.

Constructors

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)

show/hide

Instances

Eq l => Eq (RPat l)

Data l => Data (RPat l)

Ord l => Ord (RPat l)

Show l => Show (RPat l)

SrcInfo loc => Pretty (RPat loc)

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

Typeable1 RPatOp

Annotated RPatOp

Eq l => Eq (RPatOp l)

Data l => Data (RPatOp l)

Ord l => Ord (RPatOp l)

Show l => Show (RPatOp l)

Pretty (RPatOp l)

data Literal l

literal Values of this type hold the abstract value of the literal, not the precise string representation used. For example, 10, 0o12 and 0xa have the same representation.

Constructors

Char l Char String	character literal
String l String String	string literal
Int l Integer String	integer literal
Frac l Rational String	floating point literal
PrimInt l Integer String	unboxed integer literal
PrimWord l Integer String	unboxed word literal
PrimFloat l Rational String	unboxed float literal
PrimDouble l Rational String	unboxed double literal
PrimChar l Char String	unboxed character literal
PrimString l String String	unboxed string literal

show/hide

Instances

Functor Literal

Typeable1 Literal

Annotated Literal

Eq l => Eq (Literal l)

Data l => Data (Literal l)

Ord l => Ord (Literal l)

Show l => Show (Literal l)

Pretty (Literal l)

Variables, Constructors and Operators

data ModuleName l

The name of a Haskell module.

Constructors

ModuleName l String

show/hide

Instances

Functor ModuleName

Typeable1 ModuleName

Annotated ModuleName

ExactP ModuleName

Eq l => Eq (ModuleName l)

Data l => Data (ModuleName l)

Ord l => Ord (ModuleName l)

Show l => Show (ModuleName l)

Pretty (ModuleName l)

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

Typeable1 QName

Annotated QName

Eq l => Eq (QName l)

Data l => Data (QName l)

Ord l => Ord (QName l)

Show l => Show (QName l)

Pretty (QName l)

data Name l

This type is used to represent variables, and also constructors.

Constructors

Ident l String	varid or conid.
Symbol l String	varsym or consym

show/hide

Instances

Eq l => Eq (Name l)

Data l => Data (Name l)

Ord l => Ord (Name l)

Show l => Show (Name l)

Pretty (Name l)

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

Eq l => Eq (QOp l)

Data l => Data (QOp l)

Ord l => Ord (QOp l)

Show l => Show (QOp l)

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

Eq l => Eq (Op l)

Data l => Data (Op l)

Ord l => Ord (Op l)

Show l => Show (Op l)

data SpecialCon l

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

Constructors

UnitCon l	unit type and data constructor `()`
ListCon l	list type constructor `[]`
FunCon l	function type constructor `->`
TupleCon l Boxed Int	n-ary tuple type and data constructors `(,)` etc, possibly boxed `(#,#)`
Cons l	list data constructor `(:)`
UnboxedSingleCon l	unboxed singleton tuple constructor `(# #)`

show/hide

Instances

Functor SpecialCon

Typeable1 SpecialCon

Annotated SpecialCon

ExactP SpecialCon

Eq l => Eq (SpecialCon l)

Data l => Data (SpecialCon l)

Ord l => Ord (SpecialCon l)

Show l => Show (SpecialCon l)

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

Typeable1 CName

Annotated CName

Eq l => Eq (CName l)

Data l => Data (CName l)

Ord l => Ord (CName l)

Show l => Show (CName l)

Pretty (CName l)

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

Typeable1 IPName

Annotated IPName

Eq l => Eq (IPName l)

Data l => Data (IPName l)

Ord l => Ord (IPName l)

Show l => Show (IPName l)

Pretty (IPName l)

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

Typeable1 XName

Annotated XName

Eq l => Eq (XName l)

Data l => Data (XName l)

Ord l => Ord (XName l)

Show l => Show (XName l)

Pretty (XName l)

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

Functor Bracket

Typeable1 Bracket

Annotated Bracket

AppFixity Bracket

Eq l => Eq (Bracket l)

Data l => Data (Bracket l)

Ord l => Ord (Bracket l)

Show l => Show (Bracket l)

SrcInfo loc => Pretty (Bracket loc)

data Splice l

A template haskell splice expression

Constructors

IdSplice l String	variable splice: `$var`
ParenSplice l (Exp l)	parenthesised expression splice: `$(exp)`

show/hide

Instances

Typeable1 Splice

Annotated Splice

AppFixity Splice

Eq l => Eq (Splice l)

Data l => Data (Splice l)

Ord l => Ord (Splice l)

Show l => Show (Splice l)

SrcInfo loc => Pretty (Splice loc)

data Safety l

The safety of a foreign function call.

Constructors

PlayRisky l	unsafe
PlaySafe l Bool	safe (`False`) or threadsafe (`True`)

show/hide

Instances

Typeable1 Safety

Annotated Safety

Eq l => Eq (Safety l)

Data l => Data (Safety l)

Ord l => Ord (Safety l)

Show l => Show (Safety l)

Pretty (Safety l)

data CallConv l

The calling convention of a foreign function call.

Constructors

StdCall l
CCall l

show/hide

Instances

Functor CallConv

Typeable1 CallConv

Annotated CallConv

ExactP CallConv

Eq l => Eq (CallConv l)

Data l => Data (CallConv l)

Ord l => Ord (CallConv l)

Show l => Show (CallConv l)

Pretty (CallConv l)

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) String	OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC

show/hide

Instances

Functor OptionPragma

Typeable1 OptionPragma

Annotated OptionPragma

ExactP OptionPragma

Eq l => Eq (OptionPragma l)

Data l => Data (OptionPragma l)

Ord l => Ord (OptionPragma l)

Show l => Show (OptionPragma l)

Pretty (OptionPragma l)

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

Eq l => Eq (Rule l)

Data l => Data (Rule l)

Ord l => Ord (Rule l)

Show l => Show (Rule l)

SrcInfo loc => Pretty (Rule loc)

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

Functor RuleVar

Typeable1 RuleVar

Annotated RuleVar

Eq l => Eq (RuleVar l)

Data l => Data (RuleVar l)

Ord l => Ord (RuleVar l)

Show l => Show (RuleVar l)

Pretty (RuleVar l)

data Activation l

Activation clause of a RULES pragma.

Constructors

ActiveFrom l Int
ActiveUntil l Int

show/hide

Instances

Functor Activation

Typeable1 Activation

Annotated Activation

ExactP Activation

Eq l => Eq (Activation l)

Data l => Data (Activation l)

Ord l => Ord (Activation l)

Show l => Show (Activation l)

Pretty (Activation l)

prelude_mod :: l -> ModuleName l

main_mod :: l -> ModuleName l

Main function of a program

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

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 GuardedAlt

Annotated GuardedAlts

Annotated FieldUpdate

Annotated QualStmt

Annotated PatField

Annotated RPatOp

Annotated PXAttr

Annotated WarningText

Annotated RuleVar

Annotated Activation

Annotated OptionPragma

Annotated CallConv

Annotated Safety

Annotated Splice

Annotated Bracket

Annotated XAttr

Annotated XName

Annotated Literal

Annotated Context

Annotated FunDep

Annotated TyVarBind

Annotated GuardedRhs

Annotated BangType

Annotated InstDecl

Annotated ClassDecl

Annotated GadtDecl

Annotated FieldDecl

Annotated ConDecl

Annotated QualConDecl

Annotated Match

Annotated IPBind

Annotated Binds

Annotated Deriving

Annotated InstHead

Annotated DeclHead

Annotated DataOrNew

Annotated Assoc

Annotated ImportSpec

Annotated ImportSpecList

Annotated ImportDecl

Annotated ExportSpec

Annotated ExportSpecList

Annotated ModuleHead

Annotated Module

Annotated CName

Annotated IPName

Annotated QName

Annotated SpecialCon

Annotated ModuleName

Annotated PAsst

Annotated PType

Annotated PContext

Annotated ParseXAttr

Annotated PFieldUpdate

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

Test if two AST elements are equal modulo annotations.

Produced by Haddock version 2.6.0