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

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

default signature

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

unboxed component, marked with an UNPACK pragma

unguarded right hand side (exp)

guarded right hand side (gdrhs)

ordinary class assertion

constraint kind assertion, Dict :: cxt => Dict cxt

class assertion where the class name is given infix

implicit parameter assertion

type equality constraint

parenthesised class assertion

qualified type

function type

tuple type, possibly boxed

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

parallel array syntax, e.g. [: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

promoted data type (-XDataKinds)

type equality predicate enabled by ConstraintKinds

template haskell splice type

Strict type marked with "!" or type marked with UNPACK pragma.

*, the kind of types

!, the kind of unboxed types

->, the kind of a type constructor

a kind surrounded by parentheses

a kind variable (as of yet unsupported by compilers)

k1 k2

'(k1,k2,k3), a promoted tuple

'[k1,k2,k3], a promoted list literal

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

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

parallel array 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]

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

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

ordinary list comprehension

parallel list comprehension

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

case alts

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

variable

literal constant

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

quasi quote patter: [$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)

unsafe

safe (False) or threadsafe (True)

interruptible

LANGUAGE pragma

OPTIONS pragma, possibly qualified with a tool, e.g. OPTIONS_GHC

ANN pragma with module scope

NO_OVERLAP pragma

OVERLAP pragma

INCOHERENT pragma

An annotation for a declared name.

An annotation for a declared type.

An annotation for the defining module.

A variable.

And boolean formulas.

Or boolean formulas.

Parenthesized boolean formulas.