A type synonym ( type String = [Char] )

Standalone deriving declaration ( deriving instance X T )

Fixity declaration ( infixl 5 +, - )

Default types ( default (T1, T2) )

Type signature declaration ( f :: Int -> Int )

Function or value binding ( f x = 12 )

A Template Haskell splice declaration ( $(generateDecls) )

A data or newtype declaration. Empty data type declarations without where keyword are always belong to DataDecl.

A GADT-style data or newtype declaration.

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

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

Ordinary data constructor ( C t1 t2 )

Creates a record data constructor ( Point { x :: Double, y :: Double } )

Infix data constructor ( t1 :+: t2 )

Field declaration ( fld :: Int )

A deriving clause without parentheses ( deriving Show .

A deriving clause without parentheses, with/witohut strategy ( deriving stock Show .

A deriving clause with parentheses deriving (Show, Eq) )

A deriving clause with parentheses, with/witohut strategy ( deriving stock (Show, Eq) .

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

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

Type class declaration ( class X a [where f = ...] )

The list of declarations that can appear in a typeclass

Type signature: f :: A -> B as a class member

Default binding: f x = "aaa" as a class member

Declaration of an associated type synonym: type T x :: * in a class

Declaration of an associated data synonym: data T x :: * in a class

Default choice for type synonym: type T x = TE or type instance T x = TE in a class

Default signature (by using DefaultSignatures): default enum :: (Generic a, GEnum (Rep a)) => [a]

Minimal pragma: {-# MINIMAL (==) | (/=) #-} in a class

One of the minimal formulas are needed ( min1 | min2 )

Both of the minimal formulas are needed ( min1 , min2 )

Type or class name as a declaration head

Parenthesized type as a declaration head

Type application as a declaration head

Infix type application as a declaration head

Instance declaration ( instance X T [where f = ...] )

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

A normal value binding ( f x = 12 ) inside a class instance

Type signature in instance definition with InstanceSigs

An associated type definition ( type A X = B ) in a class instance

An associated data definition ( data A X = B Int | C ) in a class instance

An associated data definition as a GADT ( data A X where B :: Int -> A X ) in a class instance

Specialize instance pragma in a class instance (no phase selection is allowed)

Instance head as an instance rule ( X a => Y a )

Type or class name as an instance head

Infix application of the type/class name to the left operand as an instance head

Parenthesized instance head

Type application as an instance head

OVERLAP pragma

NO_OVERLAP pragma

OVERLAPPABLE pragma

OVERLAPPING pragma

OVERLAPS pragma

INCOHERENT pragma

Role annotations ( type role Ptr representational )

Foreign import ( foreign import foo :: Int -> IO Int )

Foreign export ( foreign export ccall foo :: Int -> IO Int )

Specifies stdcall calling convention for foreign import/export.

Specifies ccall calling convention for foreign import/export.

Specifies capi calling convention for foreign import/export.

Specifies that the given foreign import is unsafe.

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

A left hand side with a constructor name and arguments ( Arrow t1 t2 )

An infix pattern synonym left-hand side ( t1 :+: t2 )

A record-style pattern synonym left-hand side ( Arrow { arrowFrom, arrowTo } )

An automatically two-way pattern synonym ( = App "Int" [] )

A pattern synonym that can be only used for pattenr matching but not for combining ( <- App "Int" [] )

A pattern synonym with the other direction explicitly specified ( <- App "Int" [] where Int = App "Int" [] )

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

Type family declaration ( type family A a :: * -> * )

Data family declaration ( data family A a :: * -> * )

Type family instance declaration ( type instance Fam T = AssignedT )

Data instance declaration ( data instance Fam T = Con1 | Con2 )

GADT-style data instance declaration ( data instance Fam T where ... )

A closed type family declaration

Specifies the kind of a type family ( :: * -> * )

Specifies the injectivity of a type family ( = r | r -> a )

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

Top-level pragmas

A pragma that introduces source rewrite rules ( {-# RULES "map/map" [2] forall f g xs. map f (map g xs) = map (f.g) xs #-} )

A pragma that marks definitions as deprecated ( {-# DEPRECATED f "f will be replaced by g" #-} )

A pragma that marks definitions as deprecated ( {-# WARNING unsafePerformIO "you should know what you are doing" #-} )

A pragma that annotates a definition with an arbitrary value ( {-# ANN f 42 #-} )

A pragma that marks a function for inlining to the compiler ( {-# INLINE thenUs #-} )

A pragma that forbids a function from being inlined by the compiler ( {-# NOINLINE f #-} )

A pragma that marks a function that it may be inlined by the compiler ( {-# INLINABLE thenUs #-} )

A pragma for maintaining line numbers in generated sources ( {-# LINE 123 "somefile" #-} )

A pragma that tells the compiler that a polymorph function should be optimized for a given type ( {-# SPECIALISE f :: Int -> b -> b #-} )

Marks that the pragma should be applied from a given compile phase ( [2] )

Marks that the pragma should be applied until a given compile phase ( [~2] )

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

The definition with the given name is annotated

A type with the given name is annotated

The whole module is annotated

A CONLIKE modifier for an INLINE pragma.