The representation of a haskell module, that is a separate compilation unit. It may or may not have a header.

Module declaration with name and (optional) exports

A list of export specifications surrounded by parentheses

Export specifier

Marks a name to be imported or exported with related names (subspecifier)

Marks how related names will be imported or exported with a given name

Pragmas that must be used after the module head

Pragmas that must be used before defining the module

An import declaration: import Module.Name

Restriction on the imported names

Marks the import as qualified: qualified

Marks the import as source: {-# SOURCE #-}

Marks the import as safe: safe

Marks an imported name to belong to the type namespace: type

Renaming imports ( as A )

The name of a module

The name of the enabled language extension, for example ( LambdaCase )

Haskell declaration

The list of declarations that can appear in a typeclass

Members of a class declaration

Instance body is the implementation of the class functions ( where a x = 1; b x = 2 )

Declarations inside an instance declaration.

GADT constructor declaration ( D1 :: { val :: Int } -> T String )

Type of GADT constructors (can be record types: { val :: Int })

Marker for a field wildcard. Only needed to attach semantic information in a type-safe way.

A list of functional dependencies: | a -> b, c -> d separated by commas

A functional dependency, given on the form l1 ... ln -> r1 ... rn

A constructor declaration for a datatype

The data or the newtype keyword to define ADTs.

Field declaration ( fld :: Int )

A deriving clause following a data type declaration. ( deriving Show or deriving (Show, Eq) )

The instance declaration rule, which is, roughly, the part of the instance declaration before the where keyword.

The specification of the class instance declaration

Overlap pragmas. Can be applied to class declarations and class instance declarations.

Type equations as found in closed type families ( T A = S )

Top level pragmas

A rewrite rule ( "map/map" forall f g xs. map f (map g xs) = map (f.g) xs )

A variable for a rewrite rule. With or without type signature.

Annotation allows you to connect an expression to any declaration.

Formulas of minimal annotations declaring which functions should be defined.

In-AST source ranges (for generated pragmas)

Open type and data families

Type family specification with kinds specification and injectivity.

Injectivity annotation for type families ( = r | r -> a )

Pattern synonyms: pattern Arrow t1 t2 = App "->" [t1, t2]

Right-hand side of pattern synonym

Left hand side of a pattern synonym

Where clause of pattern synonym (explicit expression direction)

Pattern type signature declaration ( pattern Succ :: Int -> Int )

Role annotations for types

Call conventions of foreign functions

Safety annotations for foreign calls

A CONLIKE modifier for an INLINE pragma.

Controls the activation of a rewrite rule ( [1] )

Value binding for top-level and local bindings

Clause of function binding

Something on the left side of the match

Right hand side of a value binding (possible with guards): ( = 3 or | x == 1 = 3; | otherwise = 4 )

A guarded right-hand side of a value binding ( | x > 3 = 2 )

Guards for value bindings and pattern matches ( Just v x, v 1 )

Bindings that are enabled in local blocks (where or let).

Local bindings attached to a declaration ( where x = 42 )

A fixity signature ( infixl 5 +, - ).

A type signature ( f :: Int -> Int )

Haskell types

Type variable declarations (with possible kind annotation)

A single assertion in the context

Kind constraint ( :: * -> * )

Haskell kinds

Values promoted to the kind level

Haskell expressions

Clause of case expression ( Just x -> x + 1 )

Right hand side of a match (possible with guards): ( -> 3 or | x == 1 -> 3; | otherwise -> 4 )

A guarded right-hand side of pattern matches binding ( | x > 3 -> 2 )

Field update expressions

An element of a tuple section that can be an expression or missing (indicating a value from a parameter)

Pragmas that can be applied to expressions

Special expressions for arrows

Clause of case expression for commands

Arrow directions

A statement in a do-notation

Keywords do or mdo to start a do-block

List comprehension statement

Body of a list comprehension: ( | x <- [1..10] )

A do-notation for arrows

Representation of patterns for pattern bindings

A template haskell splice

Template Haskell bracket expressions

Template haskell quasi-quotation: [quoter|str]

Haskell literals

A definition that functions as an operator

A definition that functions as a name

Possible qualified names. Contains also implicit names. Linear implicit parameter: %x. Non-linear implicit parameter: ?x.

Parts of a qualified name.

Program elements formatted as string literals (import packages, pragma texts)