Language.Haskell.Exts.Syntax

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

Portability	portable
Stability	stable
Maintainer	Niklas Broberg, [email protected]

Description

A suite of datatypes describing the 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)

Synopsis

data Module = Module SrcLoc ModuleName [OptionPragma] (Maybe WarningText) (Maybe [ExportSpec]) [ImportDecl] [Decl]

data WarningText

= DeprText String

| WarnText String

data ExportSpec

= EVar QName

| EAbs QName

| EThingAll QName

| EThingWith QName [CName]

| EModuleContents ModuleName

data ImportDecl = ImportDecl {

importLoc :: SrcLoc

importModule :: ModuleName

importQualified :: Bool

importSrc :: Bool

importPkg :: Maybe String

importAs :: Maybe ModuleName

importSpecs :: Maybe (Bool, [ImportSpec])

}

data ImportSpec

= IVar Name

| IAbs Name

| IThingAll Name

| IThingWith Name [CName]

data Assoc

= AssocNone

| AssocLeft

| AssocRight

data Decl

= TypeDecl SrcLoc Name [TyVarBind] Type

| TypeFamDecl SrcLoc Name [TyVarBind] (Maybe Kind)

| DataDecl SrcLoc DataOrNew Context Name [TyVarBind] [QualConDecl] [Deriving]

| GDataDecl SrcLoc DataOrNew Context Name [TyVarBind] (Maybe Kind) [GadtDecl] [Deriving]

| DataFamDecl SrcLoc Context Name [TyVarBind] (Maybe Kind)

| TypeInsDecl SrcLoc Type Type

| DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving]

| GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]

| ClassDecl SrcLoc Context Name [TyVarBind] [FunDep] [ClassDecl]

| InstDecl SrcLoc Context QName [Type] [InstDecl]

| DerivDecl SrcLoc Context QName [Type]

| InfixDecl SrcLoc Assoc Int [Op]

| DefaultDecl SrcLoc [Type]

| SpliceDecl SrcLoc Exp

| TypeSig SrcLoc [Name] Type

| FunBind [Match]

| PatBind SrcLoc Pat (Maybe Type) Rhs Binds

| ForImp SrcLoc CallConv Safety String Name Type

| ForExp SrcLoc CallConv String Name Type

| RulePragmaDecl SrcLoc [Rule]

| DeprPragmaDecl SrcLoc [([Name], String)]

| WarnPragmaDecl SrcLoc [([Name], String)]

| InlineSig SrcLoc Bool Activation QName

| SpecSig SrcLoc QName [Type]

| SpecInlineSig SrcLoc Bool Activation QName [Type]

| InstSig SrcLoc Context QName [Type]

data Binds

= BDecls [Decl]

| IPBinds [IPBind]

data IPBind = IPBind SrcLoc IPName Exp

data ClassDecl

= ClsDecl Decl

| ClsDataFam SrcLoc Context Name [TyVarBind] (Maybe Kind)

| ClsTyFam SrcLoc Name [TyVarBind] (Maybe Kind)

| ClsTyDef SrcLoc Type Type

data InstDecl

= InsDecl Decl

| InsType SrcLoc Type Type

| InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving]

| InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]

| InsInline SrcLoc Bool Activation QName

type Deriving = (QName, [Type])

data DataOrNew

= DataType

| NewType

data ConDecl

= ConDecl Name [BangType]

| InfixConDecl BangType Name BangType

| RecDecl Name [([Name], BangType)]

data QualConDecl = QualConDecl SrcLoc [TyVarBind] Context ConDecl

data GadtDecl = GadtDecl SrcLoc Name Type

data BangType

= BangedTy Type

| UnBangedTy Type

| UnpackedTy Type

data Match = Match SrcLoc Name [Pat] (Maybe Type) Rhs Binds

data Rhs

= UnGuardedRhs Exp

| GuardedRhss [GuardedRhs]

data GuardedRhs = GuardedRhs SrcLoc [Stmt] Exp

type Context = [Asst]

data FunDep = FunDep [Name] [Name]

data Asst

= ClassA QName [Type]

| InfixA Type QName Type

| IParam IPName Type

| EqualP Type Type

data Type

= TyForall (Maybe [TyVarBind]) Context Type

| TyFun Type Type

| TyTuple Boxed [Type]

| TyList Type

| TyApp Type Type

| TyVar Name

| TyCon QName

| TyParen Type

| TyInfix Type QName Type

| TyKind Type Kind

data Boxed

= Boxed

| Unboxed

data Kind

= KindStar

| KindBang

| KindFn Kind Kind

| KindParen Kind

| KindVar Name

data TyVarBind

= KindedVar Name Kind

| UnkindedVar Name

data Exp

= Var QName

| IPVar IPName

| Con QName

| Lit Literal

| InfixApp Exp QOp Exp

| App Exp Exp

| NegApp Exp

| Lambda SrcLoc [Pat] Exp

| Let Binds Exp

| If Exp Exp Exp

| Case Exp [Alt]

| Do [Stmt]

| MDo [Stmt]

| Tuple [Exp]

| TupleSection [Maybe Exp]

| List [Exp]

| Paren Exp

| LeftSection Exp QOp

| RightSection QOp Exp

| RecConstr QName [FieldUpdate]

| RecUpdate Exp [FieldUpdate]

| EnumFrom Exp

| EnumFromTo Exp Exp

| EnumFromThen Exp Exp

| EnumFromThenTo Exp Exp Exp

| ListComp Exp [QualStmt]

| ParComp Exp [[QualStmt]]

| ExpTypeSig SrcLoc Exp Type

| QuasiQuote String String

| XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp]

| XETag SrcLoc XName [XAttr] (Maybe Exp)

| XPcdata String

| XExpTag Exp

| CorePragma String Exp

| SCCPragma String Exp

| GenPragma String (Int, Int) (Int, Int) Exp

| Proc Pat Exp

| LeftArrApp Exp Exp

| RightArrApp Exp Exp

| LeftArrHighApp Exp Exp

| RightArrHighApp Exp Exp

data Stmt

= Generator SrcLoc Pat Exp

| Qualifier Exp

| LetStmt Binds

| RecStmt [Stmt]

data QualStmt

= QualStmt Stmt

| ThenTrans Exp

| ThenBy Exp Exp

| GroupBy Exp

| GroupUsing Exp

| GroupByUsing Exp Exp

data FieldUpdate

= FieldUpdate QName Exp

| FieldPun Name

| FieldWildcard

data Alt = Alt SrcLoc Pat GuardedAlts Binds

data GuardedAlts

= UnGuardedAlt Exp

| GuardedAlts [GuardedAlt]

data GuardedAlt = GuardedAlt SrcLoc [Stmt] Exp

data XAttr = XAttr XName Exp

data Pat

= PVar Name

| PLit Literal

| PNeg Pat

| PNPlusK Name Integer

| PInfixApp Pat QName Pat

| PApp QName [Pat]

| PTuple [Pat]

| PList [Pat]

| PParen Pat

| PRec QName [PatField]

| PAsPat Name Pat

| PWildCard

| PIrrPat Pat

| PatTypeSig SrcLoc Pat Type

| PViewPat Exp Pat

| PRPat [RPat]

| PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat]

| PXETag SrcLoc XName [PXAttr] (Maybe Pat)

| PXPcdata String

| PXPatTag Pat

| PXRPats [RPat]

| PExplTypeArg QName Type

| PQuasiQuote String String

| PBangPat Pat

data PatField

= PFieldPat QName Pat

| PFieldPun Name

| PFieldWildcard

data PXAttr = PXAttr XName Pat

data RPat

= RPOp RPat RPatOp

| RPEither RPat RPat

| RPSeq [RPat]

| RPGuard Pat [Stmt]

| RPCAs Name RPat

| RPAs Name RPat

| RPParen RPat

| RPPat Pat

data RPatOp

= RPStar

| RPStarG

| RPPlus

| RPPlusG

| RPOpt

| RPOptG

data Literal

= Char Char

| Int Integer

| PrimDouble Rational

| PrimChar Char

| PrimString String

newtype ModuleName = ModuleName String

data QName

= Qual ModuleName Name

| UnQual Name

| Special SpecialCon

data Name

= Ident String

| Symbol String

data QOp

= QVarOp QName

| QConOp QName

data Op

= VarOp Name

| ConOp Name

data SpecialCon

= UnitCon

| ListCon

| FunCon

| TupleCon Boxed Int

| Cons

| UnboxedSingleCon

data CName

= VarName Name

| ConName Name

data IPName

= IPDup String

| IPLin String

data XName

= XName String

| XDomName String String

data Bracket

= ExpBracket Exp

| PatBracket Pat

| TypeBracket Type

| DeclBracket [Decl]

data Splice

data Safety

data CallConv

= StdCall

| CCall

data OptionPragma

= LanguagePragma SrcLoc [Name]

| IncludePragma SrcLoc String

| CFilesPragma SrcLoc String

| OptionsPragma SrcLoc (Maybe Tool) String

data Tool

= GHC

| HUGS

| NHC98

| YHC

| HADDOCK

| UnknownTool String

data Rule = Rule String Activation (Maybe [RuleVar]) Exp Exp

data RuleVar

= RuleVar Name

| TypedRuleVar Name Type

data Activation

= AlwaysActive

| ActiveFrom Int

| ActiveUntil Int

prelude_mod :: ModuleName

main_mod :: ModuleName

main_name :: Name

unit_con_name :: QName

tuple_con_name :: Boxed -> Int -> QName

list_cons_name :: QName

unboxed_singleton_con_name :: QName

unit_con :: Exp

tuple_con :: Boxed -> Int -> Exp

unboxed_singleton_con :: Exp

as_name :: Name

qualified_name :: Name

hiding_name :: Name

minus_name :: Name

bang_name :: Name

dot_name :: Name

star_name :: Name

export_name :: Name

safe_name :: Name

unsafe_name :: Name

threadsafe_name :: Name

stdcall_name :: Name

ccall_name :: Name

unit_tycon_name :: QName

fun_tycon_name :: QName

list_tycon_name :: QName

tuple_tycon_name :: Boxed -> Int -> QName

unboxed_singleton_tycon_name :: QName

unit_tycon :: Type

fun_tycon :: Type

list_tycon :: Type

tuple_tycon :: Boxed -> Int -> Type

unboxed_singleton_tycon :: Type

data SrcLoc = SrcLoc {

srcFilename :: String

srcLine :: Int

srcColumn :: Int

}

Modules

data Module

Source

A complete Haskell source module.

Constructors

Module SrcLoc ModuleName [OptionPragma] (Maybe WarningText) (Maybe [ExportSpec]) [ImportDecl] [Decl]

Instances

data WarningText

Warning text to optionally use in the module header of e.g. a deprecated module.

Constructors

DeprText String
WarnText String

Instances

data ExportSpec

An item in a module's export specification.

Constructors

EVar QName	variable
EAbs QName	`T`: a class or datatype exported abstractly, or a type synonym.
EThingAll QName	`T(..)`: a class exported with all of its methods, or a datatype exported with all of its constructors.
EThingWith QName [CName]	`T(C_1,...,C_n)`: a class exported with some of its methods, or a datatype exported with some of its constructors.
EModuleContents ModuleName	`module M`: re-export a module.

Instances

data ImportDecl

An import declaration.

Constructors

ImportDecl

importLoc :: SrcLoc	position of the `import` keyword.
importModule :: ModuleName	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	optional alias name in an `as` clause.
importSpecs :: Maybe (Bool, [ImportSpec])	optional list of import specifications. The `Bool` is `True` if the names are excluded by `hiding`.

Instances

data ImportSpec

An import specification, representing a single explicit item imported (or hidden) from a module.

Constructors

IVar Name	variable
IAbs Name	`T`: the name of a class, datatype or type synonym.
IThingAll Name	`T(..)`: a class imported with all of its methods, or a datatype imported with all of its constructors.
IThingWith Name [CName]	`T(C_1,...,C_n)`: a class imported with some of its methods, or a datatype imported with some of its constructors.

Instances

data Assoc

Associativity of an operator.

Constructors

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

Instances

data Decl

A top-level declaration.

Constructors

TypeDecl SrcLoc Name [TyVarBind] Type	A type declaration
TypeFamDecl SrcLoc Name [TyVarBind] (Maybe Kind)	A type family declaration
DataDecl SrcLoc DataOrNew Context Name [TyVarBind] [QualConDecl] [Deriving]	A data OR newtype declaration
GDataDecl SrcLoc DataOrNew Context Name [TyVarBind] (Maybe Kind) [GadtDecl] [Deriving]	A data OR newtype declaration, GADT style
DataFamDecl SrcLoc Context Name [TyVarBind] (Maybe Kind)	A data family declaration
TypeInsDecl SrcLoc Type Type	A type family instance declaration
DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving]	A data family instance declaration
GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]	A data family instance declaration, GADT style
ClassDecl SrcLoc Context Name [TyVarBind] [FunDep] [ClassDecl]	A declaration of a type class
InstDecl SrcLoc Context QName [Type] [InstDecl]	An declaration of a type class instance
DerivDecl SrcLoc Context QName [Type]	A standalone deriving declaration
InfixDecl SrcLoc Assoc Int [Op]	A declaration of operator fixity
DefaultDecl SrcLoc [Type]	A declaration of default types
SpliceDecl SrcLoc Exp	A Template Haskell splicing declaration
TypeSig SrcLoc [Name] Type	A type signature declaration
FunBind [Match]	A set of function binding clauses
PatBind SrcLoc Pat (Maybe Type) Rhs Binds	A pattern binding
ForImp SrcLoc CallConv Safety String Name Type	A foreign import declaration
ForExp SrcLoc CallConv String Name Type	A foreign export declaration
RulePragmaDecl SrcLoc [Rule]	A RULES pragma
DeprPragmaDecl SrcLoc [([Name], String)]	A DEPRECATED pragma
WarnPragmaDecl SrcLoc [([Name], String)]	A WARNING pragma
InlineSig SrcLoc Bool Activation QName	An INLINE pragma
SpecSig SrcLoc QName [Type]	A SPECIALISE pragma
SpecInlineSig SrcLoc Bool Activation QName [Type]	A SPECIALISE INLINE pragma
InstSig SrcLoc Context QName [Type]	A SPECIALISE instance pragma

Instances

data Binds

A binding group inside a let or where clause.

Constructors

BDecls [Decl]	An ordinary binding group
IPBinds [IPBind]	A binding group for implicit parameters

Instances

data IPBind

A binding of an implicit parameter.

Constructors

IPBind SrcLoc IPName Exp

Instances

Type classes and instances

data ClassDecl

Source

Declarations inside a class declaration.

Constructors

ClsDecl Decl	ordinary declaration
ClsDataFam SrcLoc Context Name [TyVarBind] (Maybe Kind)	declaration of an associated data type
ClsTyFam SrcLoc Name [TyVarBind] (Maybe Kind)	declaration of an associated type synonym
ClsTyDef SrcLoc Type Type	default choice for an associated type synonym

Instances

data InstDecl

Declarations inside an instance declaration.

Constructors

InsDecl Decl	ordinary declaration
InsType SrcLoc Type Type	an associated type definition
InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving]	an associated data type implementation
InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving]	an associated data type implemented using GADT style
InsInline SrcLoc Bool Activation QName	an INLINE pragma

Instances

type Deriving = (QName, [Type])

Source

A single derived instance, which may have arguments since it may be a MPTC.

Data type declarations

data DataOrNew

Source

A flag stating whether a declaration is a data or newtype declaration.

Constructors

DataType
NewType

Instances

data ConDecl

Declaration of an ordinary data constructor.

Constructors

ConDecl Name [BangType]	ordinary data constructor
InfixConDecl BangType Name BangType	infix data constructor
RecDecl Name [([Name], BangType)]	record constructor

Instances

data QualConDecl

A single constructor declaration within a data type declaration, which may have an existential quantification binding.

Constructors

QualConDecl SrcLoc [TyVarBind] Context ConDecl

Instances

data GadtDecl

A single constructor declaration in a GADT data type declaration.

Constructors

GadtDecl SrcLoc Name Type

Instances

data BangType

The type of a constructor argument or field, optionally including a strictness annotation.

Constructors

BangedTy Type	strict component, marked with "`!`"
UnBangedTy Type	non-strict component
UnpackedTy Type	unboxed component, marked with an UNPACK pragma

Instances

data Match

Clauses of a function binding.

Constructors

Match SrcLoc Name [Pat] (Maybe Type) Rhs Binds

Instances

data Rhs

The right hand side of a function or pattern binding.

Constructors

UnGuardedRhs Exp	unguarded right hand side (exp)
GuardedRhss [GuardedRhs]	guarded right hand side (gdrhs)

Instances

data GuardedRhs

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 SrcLoc [Stmt] Exp

Instances

Class Assertions and Contexts

type Context = [Asst]

Source

A context is a set of assertions

data FunDep

Source

A functional dependency, given on the form l1 l2 ... ln -> r2 r3 .. rn

Constructors

FunDep [Name] [Name]

Instances

data Asst

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 QName [Type]	ordinary class assertion
InfixA Type QName Type	class assertion where the class name is given infix
IParam IPName Type	implicit parameter assertion
EqualP Type Type	type equality constraint

Instances

data Type

A type qualified with a context. An unqualified type has an empty context.

Constructors

TyForall (Maybe [TyVarBind]) Context Type	qualified type
TyFun Type Type	function type
TyTuple Boxed [Type]	tuple type, possibly boxed
TyList Type	list syntax, e.g. [a], as opposed to [] a
TyApp Type Type	application of a type constructor
TyVar Name	type variable
TyCon QName	named type or type constructor
TyParen Type	type surrounded by parentheses
TyInfix Type QName Type	infix type constructor
TyKind Type Kind	type with explicit kind signature

Instances

data Boxed

Flag denoting whether a tuple is boxed or unboxed.

Constructors

Boxed
Unboxed

Instances

data Kind

An explicit kind annotation.

Constructors

KindStar	`*`, the kind of types
KindBang	`!`, the kind of unboxed types
KindFn Kind Kind	`->`, the kind of a type constructor
KindParen Kind	a kind surrounded by parentheses
KindVar Name	a kind variable (as of yet unsupported by compilers)

Instances

data TyVarBind

A type variable declaration, optionally with an explicit kind annotation.

Constructors

KindedVar Name Kind	variable binding with kind annotation
UnkindedVar Name	ordinary variable binding

Instances

data Exp

Haskell expressions.

Constructors

Var QName	variable
IPVar IPName	implicit parameter variable
Con QName	data constructor
Lit Literal	literal constant
InfixApp Exp QOp Exp	infix application
App Exp Exp	ordinary application
NegApp Exp	negation expression `-exp` (unary minus)
Lambda SrcLoc [Pat] Exp	lambda expression
Let Binds Exp	local declarations with `let` ... `in` ...
If Exp Exp Exp	`if` exp `then` exp `else` exp
Case Exp [Alt]	`case` exp `of` alts
Do [Stmt]	`do`-expression: the last statement in the list should be an expression.
MDo [Stmt]	`mdo`-expression
Tuple [Exp]	tuple expression
TupleSection [Maybe Exp]	tuple section expression, e.g. `(,,3)`
List [Exp]	list expression
Paren Exp	parenthesised expression
LeftSection Exp QOp	left section `(`exp qop`)`
RightSection QOp Exp	right section `(`qop exp`)`
RecConstr QName [FieldUpdate]	record construction expression
RecUpdate Exp [FieldUpdate]	record update expression
EnumFrom Exp	unbounded arithmetic sequence, incrementing by 1: `[from ..]`
EnumFromTo Exp Exp	bounded arithmetic sequence, incrementing by 1 `[from .. to]`
EnumFromThen Exp Exp	unbounded arithmetic sequence, with first two elements given `[from, then ..]`
EnumFromThenTo Exp Exp Exp	bounded arithmetic sequence, with first two elements given `[from, then .. to]`
ListComp Exp [QualStmt]	ordinary list comprehension
ParComp Exp [[QualStmt]]	parallel list comprehension
ExpTypeSig SrcLoc Exp Type	expression with explicit type signature
VarQuote QName	`'x` for template haskell reifying of expressions
TypQuote QName	`''T` for template haskell reifying of types
BracketExp Bracket	template haskell bracket expression
SpliceExp Splice	template haskell splice expression
QuasiQuote String String	quasi-quotaion: `[$name\| string \|]`
XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp]	xml element, with attributes and children
XETag SrcLoc XName [XAttr] (Maybe Exp)	empty xml element, with attributes
XPcdata String	PCDATA child element
XExpTag Exp	escaped haskell expression inside xml
CorePragma String Exp	CORE pragma
SCCPragma String Exp	SCC pragma
GenPragma String (Int, Int) (Int, Int) Exp	GENERATED pragma
Proc Pat Exp	arrows proc: `proc` pat `->` exp
LeftArrApp Exp Exp	arrow application (from left): exp `-<` exp
RightArrApp Exp Exp	arrow application (from right): exp `>-` exp
LeftArrHighApp Exp Exp	higher-order arrow application (from left): exp `-<<` exp
RightArrHighApp Exp Exp	higher-order arrow application (from right): exp `>>-` exp

Instances

data Stmt

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 SrcLoc Pat Exp	a generator: pat `<-` exp
Qualifier Exp	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 Binds	local bindings
RecStmt [Stmt]	a recursive binding group for arrows

Instances

data QualStmt

A general transqual in a list comprehension, which could potentially be a transform of the kind enabled by TransformListComp.

Constructors

QualStmt Stmt	an ordinary statement
ThenTrans Exp	`then` exp
ThenBy Exp Exp	`then` exp `by` exp
GroupBy Exp	`then` `group` `by` exp
GroupUsing Exp	`then` `group` `using` exp
GroupByUsing Exp Exp	`then` `group` `by` exp `using` exp

Instances

data FieldUpdate

An fbind in a labeled construction or update expression.

Constructors

FieldUpdate QName Exp	ordinary label-expresion pair
FieldPun Name	record field pun
FieldWildcard	record field wildcard

Instances

AppFixity FieldUpdate

Pretty FieldUpdate

data Alt

Source

An alt alternative in a case expression.

Constructors

Alt SrcLoc Pat GuardedAlts Binds

Instances

data GuardedAlts

The right-hand sides of a case alternative, which may be a single right-hand side or a set of guarded ones.

Constructors

UnGuardedAlt Exp	`->` exp
GuardedAlts [GuardedAlt]	gdpat

Instances

AppFixity GuardedAlts

Pretty GuardedAlts

data GuardedAlt

Source

A guarded case alternative | stmts -> exp.

Constructors

GuardedAlt SrcLoc [Stmt] Exp

Instances

data XAttr

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

Constructors

XAttr XName Exp

Instances

data Pat

A pattern, to be matched against a value.

Constructors

PVar Name	variable
PLit Literal	literal constant
PNeg Pat	negated pattern
PNPlusK Name Integer	n+k pattern
PInfixApp Pat QName Pat	pattern with an infix data constructor
PApp QName [Pat]	data constructor and argument patterns
PTuple [Pat]	tuple pattern
PList [Pat]	list pattern
PParen Pat	parenthesized pattern
PRec QName [PatField]	labelled pattern, record style
PAsPat Name Pat	`@`-pattern
PWildCard	wildcard pattern: `_`
PIrrPat Pat	irrefutable pattern: `~pat`
PatTypeSig SrcLoc Pat Type	pattern with type signature
PViewPat Exp Pat	view patterns of the form `(exp -> pat)`
PRPat [RPat]	regular list pattern
PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat]	XML element pattern
PXETag SrcLoc XName [PXAttr] (Maybe Pat)	XML singleton element pattern
PXPcdata String	XML PCDATA pattern
PXPatTag Pat	XML embedded pattern
PXRPats [RPat]	XML regular list pattern
PExplTypeArg QName Type	Explicit generics style type argument e.g. `f {\| Int \|} x = ...`
PQuasiQuote String String	quasi quote patter: `[$name\| string \|]`
PBangPat Pat	strict (bang) pattern: `f !x = ...`

Instances

data PatField

An fpat in a labeled record pattern.

Constructors

PFieldPat QName Pat	ordinary label-pattern pair
PFieldPun Name	record field pun
PFieldWildcard	record field wildcard

Instances

data PXAttr

An XML attribute in a pattern.

Constructors

PXAttr XName Pat

Instances

data RPat

An entity in a regular pattern.

Constructors

RPOp RPat RPatOp
RPEither RPat RPat
RPSeq [RPat]
RPGuard Pat [Stmt]
RPCAs Name RPat
RPAs Name RPat
RPParen RPat
RPPat Pat

Instances

data RPatOp

A regular pattern operator.

Constructors

RPStar	`*` = 0 or more
RPStarG	`*!` = 0 or more, greedy
RPPlus	`+` = 1 or more
RPPlusG	`+!` = 1 or more, greedy
RPOpt	`?` = 0 or 1
RPOptG	`?!` = 0 or 1, greedy

Instances

data Literal

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 Char	character literal
String String	string literal
Int Integer	integer literal
Frac Rational	floating point literal
PrimInt Integer	unboxed integer literal
PrimWord Integer	unboxed word literal
PrimFloat Rational	unboxed float literal
PrimDouble Rational	unboxed double literal
PrimChar Char	unboxed character literal
PrimString String	unboxed string literal

Instances

Variables, Constructors and Operators

newtype ModuleName

Source

The name of a Haskell module.

Constructors

ModuleName String

Instances

data QName

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

Constructors

Qual ModuleName Name	name qualified with a module name
UnQual Name	unqualified local name
Special SpecialCon	built-in constructor with special syntax

Instances

data Name

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

Constructors

Ident String	varid or conid.
Symbol String	varsym or consym

Instances

data QOp

Possibly qualified infix operators (qop), appearing in expressions.

Constructors

QVarOp QName	variable operator (qvarop)
QConOp QName	constructor operator (qconop)

Instances

data Op

Operators appearing in infix declarations are never qualified.

Constructors

VarOp Name	variable operator (varop)
ConOp Name	constructor operator (conop)

Instances

data SpecialCon

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

Constructors

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

Instances

data CName

A name (cname) of a component of a class or data type in an import or export specification.

Constructors

VarName Name	name of a method or field
ConName Name	name of a data constructor

Instances

data IPName

An implicit parameter name.

Constructors

IPDup String	?ident, non-linear implicit parameter
IPLin String	%ident, linear implicit parameter

Instances

data XName

The name of an xml element or attribute, possibly qualified with a namespace.

Constructors

XName String
XDomName String String

Instances

data Bracket

A template haskell bracket expression.

Constructors

ExpBracket Exp	expression bracket: `[\| ... \|]`
PatBracket Pat	pattern bracket: `[p\| ... \|]`
TypeBracket Type	type bracket: `[t\| ... \|]`
DeclBracket [Decl]	declaration bracket: `[d\| ... \|]`

Instances

data Splice

A template haskell splice expression

Constructors

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

Instances

data Safety

The safety of a foreign function call.

Constructors

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

Instances

data CallConv

The calling convention of a foreign function call.

Constructors

StdCall
CCall

Instances

data OptionPragma

Source

A top level options pragma, preceding the module header.

Constructors

LanguagePragma SrcLoc [Name]	LANGUAGE pragma
IncludePragma SrcLoc String	INCLUDE pragma
CFilesPragma SrcLoc String	CFILES pragma
OptionsPragma SrcLoc (Maybe Tool) String	OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC