an ordinary Haskell module

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.

a hybrid module combining an XML document with an ordinary module

variable

T: a class or datatype exported abstractly, or a type synonym.

T(..): a class exported with all of its methods, or a datatype exported with all of its constructors.

T(C_1,...,C_n): a class exported with some of its methods, or a datatype exported with some of its constructors.

module M: re-export a module.

variable

T: the name of a class, datatype or type synonym.

T(..): a class imported with all of its methods, or a datatype imported with all of its constructors.

T(C_1,...,C_n): a class imported with some of its methods, or a datatype imported with some of its constructors.

non-associative operator (declared with infix)

left-associative operator (declared with infixl).

right-associative operator (declared with infixr)

A type declaration

A type family declaration

A data OR newtype declaration

A data OR newtype declaration, GADT style

A data family declaration

A type family instance declaration

A data family instance declaration

A data family instance declaration, GADT style

A declaration of a type class

An declaration of a type class instance

A standalone deriving declaration

A declaration of operator fixity

A declaration of default types

A Template Haskell splicing declaration

A type signature declaration

A set of function binding clauses

A pattern binding

A foreign import declaration

A foreign export declaration

A RULES pragma

A DEPRECATED pragma

A WARNING pragma

An INLINE pragma

An INLINE CONLIKE pragma

A SPECIALISE pragma

A SPECIALISE INLINE pragma

A SPECIALISE instance pragma

An ANN pragma

An ordinary binding group

A binding group for implicit parameters

ordinary declaration

declaration of an associated data type

declaration of an associated type synonym

default choice for an associated type synonym

ordinary declaration

an associated type definition

an associated data type implementation

an associated data type implemented using GADT style

ordinary data constructor

infix data constructor

record constructor

strict component, marked with "!"

non-strict component

unboxed component, marked with an UNPACK pragma

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.

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.

unguarded right hand side (exp)

guarded right hand side (gdrhs)

ordinary class assertion

class assertion where the class name is given infix

implicit parameter assertion

type equality constraint

qualified type

function type

tuple type, possibly boxed

list syntax, e.g. [a], as opposed to [] a

application of a type constructor

type variable

named type or type constructor

type surrounded by parentheses

infix type constructor

type with explicit kind signature

*, the kind of types

!, the kind of unboxed types

->, the kind of a type constructor

a parenthesised kind

a kind variable (as-of-yet unsupported by compilers)

variable binding with kind annotation

ordinary variable binding

variable

implicit parameter variable

data constructor

literal constant

infix application

ordinary application

negation expression -exp (unary minus)

lambda expression

local declarations with let ... in ...

if exp then exp else exp

case exp of alts

do-expression: the last statement in the list should be an expression.

mdo-expression

tuple expression

tuple section expression, e.g. (,,3)

list expression

parenthesised expression

left section (exp qop)

right section (qop exp)

record construction expression

record update expression

unbounded arithmetic sequence, incrementing by 1: [from ..]

bounded arithmetic sequence, incrementing by 1 [from .. to]

unbounded arithmetic sequence, with first two elements given [from, then ..]

bounded arithmetic sequence, with first two elements given [from, then .. to]

ordinary list comprehension

parallel list comprehension

expression with explicit type signature

'x for template haskell reifying of expressions

''T for template haskell reifying of types

template haskell bracket expression

template haskell splice expression

quasi-quotaion: [$name| string |]

xml element, with attributes and children

empty xml element, with attributes

PCDATA child element

escaped haskell expression inside xml

children of an xml element

CORE pragma

SCC pragma

GENERATED pragma

arrows proc: proc pat -> exp

arrow application (from left): exp -< exp

arrow application (from right): exp >- exp

higher-order arrow application (from left): exp -<< exp

higher-order arrow application (from right): exp >>- exp

a generator: pat <- 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

local bindings

a recursive binding group for arrows

an ordinary statement

then exp

then exp by exp

then group by exp

then group using exp

then group by exp using exp

ordinary label-expresion pair

record field pun

record field wildcard

-> exp

gdpat

variable

literal constant

negated pattern

n+k pattern

pattern with an infix data constructor

data constructor and argument patterns

tuple pattern

list pattern

parenthesized pattern

labelled pattern, record style

@-pattern

wildcard pattern: _

irrefutable pattern: ~pat

pattern with type signature

view patterns of the form (exp -> pat)

regular list pattern

XML element pattern

XML singleton element pattern

XML PCDATA pattern

XML embedded pattern

XML regular list pattern

Explicit generics style type argument e.g. f {| Int |} x = ...

quasi quote pattern: [$name| string |]

strict (bang) pattern: f !x = ...

ordinary label-pattern pair

record field pun

record field wildcard

operator pattern, e.g. pat*

choice pattern, e.g. (1 | 2)

sequence pattern, e.g. (| 1, 2, 3 |)

guarded pattern, e.g. (| p | p < 3 |)

non-linear variable binding, e.g. (foo@:(1 | 2))*

linear variable binding, e.g. foo@(1 | 2)

parenthesised pattern, e.g. (2*)

an ordinary pattern

* = 0 or more

*! = 0 or more, greedy

+ = 1 or more

+! = 1 or more, greedy

? = 0 or 1

?! = 0 or 1, greedy

character literal

string literal

integer literal

floating point literal

unboxed integer literal

unboxed word literal

unboxed float literal

unboxed double literal

unboxed character literal

unboxed string literal

name qualified with a module name

unqualified local name

built-in constructor with special syntax

varid or conid.

varsym or consym

variable operator (qvarop)

constructor operator (qconop)

variable operator (varop)

constructor operator (conop)

unit type and data constructor ()

list type constructor []

function type constructor ->

n-ary tuple type and data constructors (,) etc, possibly boxed (#,#)

list data constructor (:)

unboxed singleton tuple constructor (# #)

name of a method or field

name of a data constructor

?ident, non-linear implicit parameter

%ident, linear implicit parameter

expression bracket: [| ... |]

pattern bracket: [p| ... |]

type bracket: [t| ... |]

declaration bracket: [d| ... |]

variable splice: $var

parenthesised expression splice: $(exp)