Creates a type synonym ( type String = [Char] )

Creates a standalone deriving declaration ( deriving instance X T )

Creates a fixity declaration ( infixl 5 +, - )

Creates default types ( default (T1, T2) )

Creates type signature declaration ( f :: Int -> Int )

Creates a function or value binding ( f x = 12 )

Creates a Template Haskell splice declaration ( $(generateDecls) )

Creates a data or newtype declaration.

Creates a GADT-style data or newtype declaration.

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

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

Creates an ordinary data constructor ( C t1 t2 )

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

Creates an infix data constructor ( t1 :+: t2 )

Creates a field declaration ( fld :: Int ) for a constructor

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

The data keyword in a type definition

The newtype keyword in a type definition

Creates a type class declaration ( class X a where f = ... )

Creates the list of declarations that can appear in a typeclass

Creates a type signature as class element: f :: A -> B

Creates a default binding as class element: f x = "aaa"

Creates an associated type synonym in class: type T y :: *

Creates an associated data synonym in class: data T y :: *

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

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

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

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

Application in a declaration head

Infix application of the type/class name to the left operand in a declaration head

Creates a type class instance declaration ( instance X T [where f = ...] )

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

Type or class name as a part of the instance declaration

Infix application of the type/class name to the left operand as a part of the instance declaration

Parenthesized instance head as a part of the instance declaration

Application to one more type as a part of the instance declaration

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

A normal declaration ( f x = 12 ) in a type class instance

Type signature in instance definition with InstanceSigs

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

An associated data type implementation ( data A X = C1 | C2 ) int a type class instance

An associated data type implemented using GADT style int a type class instance

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

OVERLAP pragma for type instance definitions

NO_OVERLAP pragma for type instance definitions

OVERLAPPABLE pragma for type instance definitions

OVERLAPPING pragma for type instance definitions

OVERLAPS pragma for type instance definitions

INCOHERENT pragma for type instance definitions

Creates a role annotations ( type role Ptr representational )

Marks a given type parameter as nominal.

Marks a given type parameter as representational.

Marks a given type parameter as phantom.

Creates a foreign import ( foreign import foo :: Int -> IO Int )

Creates a 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.

Creates a type family declaration ( type family F x )

Creates a closed type family declaration ( type family F x where F Int = (); F a = Int )

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

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 )

Creates a type family instance declaration ( type instance Fam T = AssignedT )

Creates a data instance declaration ( data instance Fam T = Con1 | Con2 )

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

Creates a pattern synonym ( pattern Arrow t1 t2 = App "->" [t1, t2] )

Creates a left hand side of a pattern synonym with a constructor name and arguments ( Arrow t1 t2 )

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

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

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

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

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

Creates a pattern type signature declaration ( pattern Succ :: Int -> Int )

Creates a 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.