6.4.10. Datatype promotion¶
This section describes data type promotion, an extension to the kind
system that complements kind polymorphism. It is enabled by
DataKinds
, and described in more detail in the paper Giving
Haskell a Promotion, which
appeared at TLDI 2012.
See also TypeData
for a more finegrained alternative.
6.4.10.1. Motivation¶
Standard Haskell has a rich type language. Types classify terms and
serve to avoid many common programming mistakes. The kind language,
however, is relatively simple, distinguishing only regular types (kind
Type
) and type constructors (e.g. kind Type > Type > Type
).
In particular when using advanced type
system features, such as type families (Type families) or GADTs
(Generalised Algebraic Data Types (GADTs)), this simple kind system is insufficient, and fails to
prevent simple errors. Consider the example of typelevel natural
numbers, and lengthindexed vectors:
data Ze
data Su n
data Vec :: Type > Type > Type where
Nil :: Vec a Ze
Cons :: a > Vec a n > Vec a (Su n)
The kind of Vec
is Type > Type > Type
. This means that, e.g.,
Vec Int Char
is a wellkinded type, even though this is not what we
intend when defining lengthindexed vectors.
With DataKinds
, the example above can then be rewritten to:
data Nat = Ze  Su Nat
data Vec :: Type > Nat > Type where
Nil :: Vec a Ze
Cons :: a > Vec a n > Vec a (Su n)
With the improved kind of Vec
, things like Vec Int Char
are now
illkinded, and GHC will report an error.
6.4.10.2. Overview¶
With DataKinds
, GHC automatically promotes every datatype
to be a kind and its (value) constructors to be type constructors. The
following types
data Nat = Zero  Succ Nat
data List a = Nil  Cons a (List a)
data Pair a b = MkPair a b
data Sum a b = L a  R b
give rise to the following kinds and type constructors:
Nat :: Type
Zero :: Nat
Succ :: Nat > Nat
List :: Type > Type
Nil :: forall k. List k
Cons :: forall k. k > List k > List k
Pair :: Type > Type > Type
MkPair :: forall k1 k2. k1 > k2 > Pair k1 k2
Sum :: Type > Type > Type
L :: k1 > Sum k1 k2
R :: k2 > Sum k1 k2
Virtually all data constructors, even those with rich kinds, can be promoted. There are only a couple of exceptions to this rule:
Data family instance constructors cannot be promoted at the moment. GHC’s type theory just isn’t up to the task of promoting data families, which requires full dependent types.
Data constructors with contexts cannot be promoted. For example:
data Foo :: Type > Type where MkFoo :: Show a => Foo a  not promotable
The following kinds and promoted data constructors can be used even when
DataKinds
is not enabled:
Type
TYPE
(see Representation polymorphism)Constraint
(see The Constraint kind)CONSTRAINT
Multiplicity
and its promoted data constructors (seeLinearTypes
)LiftedRep
(see Representation polymorphism)RuntimeRep
and its promoted data constructors (see Representation polymorphism)Levity
and its promoted data constructors (see Representation polymorphism)VecCount
and its promoted data constructorsVecElem
and its promoted data constructors
It is also possible to use kinds declared with type data
(see
TypeData
) without enabling DataKinds
.
6.4.10.3. Distinguishing between types and constructors¶
Consider
data P = MkP  1
data Prom = P  2
The name P
on the type level will refer to the type P
(which has
a constructor MkP
) rather than the promoted data constructor
P
of kind Prom
. To refer to the latter, prefix it with a
single quote mark: 'P
.
This syntax can be used even if there is no ambiguity (i.e.
there’s no type P
in scope).
GHC supports Wuntickedpromotedconstructors
that warns
whenever a promoted data constructor is written without a quote mark.
As of GHC 9.4, this warning is no longer enabled by Wall
;
we no longer recommend quote marks as a preferred default
(see #20531).
Just as in the case of Template Haskell (Syntax), GHC gets confused if you put a quote mark before a data constructor whose second character is a quote mark. In this case, just put a space between the promotion quote and the data constructor:
data T = A'
type S = 'A'  ERROR: looks like a character
type R = ' A'  OK: promoted `A'`
6.4.10.4. Typelevel literals¶
DataKinds
enables the use of numeric and string literals at the
type level. For more information, see TypeLevel Literals.
6.4.10.5. Promoted list and tuple types¶
With DataKinds
, Haskell’s list and tuple types are natively
promoted to kinds, and enjoy the same convenient syntax at the type
level, albeit prefixed with a quote:
data HList :: [Type] > Type where
HNil :: HList '[]
HCons :: a > HList t > HList (a ': t)
data Tuple :: (Type,Type) > Type where
Tuple :: a > b > Tuple '(a,b)
foo0 :: HList '[]
foo0 = HNil
foo1 :: HList '[Int]
foo1 = HCons (3::Int) HNil
foo2 :: HList [Int, Bool]
foo2 = ...
For typelevel lists of two or more elements, such as the signature of
foo2
above, the quote may be omitted because the meaning is unambiguous. But
for lists of one or zero elements (as in foo0
and foo1
), the quote is
required, because the types []
and [Int]
have existing meanings in
Haskell.
Note
The declaration for HCons
also requires TypeOperators
because of infix type operator (':)
6.4.10.6. Promoting existential data constructors¶
Note that we do promote existential data constructors that are otherwise suitable. For example, consider the following:
data Ex :: Type where
MkEx :: forall a. a > Ex
Both the type Ex
and the data constructor MkEx
get promoted,
with the polymorphic kind 'MkEx :: forall k. k > Ex
. Somewhat
surprisingly, you can write a type family to extract the member of a
typelevel existential:
type family UnEx (ex :: Ex) :: k
type instance UnEx (MkEx x) = x
At first blush, UnEx
seems poorlykinded. The return kind k
is
not mentioned in the arguments, and thus it would seem that an instance
would have to return a member of k
for any k
. However, this is
not the case. The type family UnEx
is a kindindexed type family.
The return kind k
is an implicit parameter to UnEx
. The
elaborated definitions are as follows (where implicit parameters are
denoted by braces):
type family UnEx {k :: Type} (ex :: Ex) :: k
type instance UnEx {k} (MkEx @k x) = x
Thus, the instance triggers only when the implicit parameter to UnEx
matches the implicit parameter to MkEx
. Because k
is actually a
parameter to UnEx
, the kind is not escaping the existential, and the
above code is valid.
See also #7347.
6.4.10.7. DataKinds
and type synonyms¶
The DataKinds
extension interacts with type synonyms in the
following ways:
In a type context:
DataKinds
is not required to use a type synonym that expands to a type that would otherwise require the extension. For example:{# LANGUAGE DataKinds #} module A where type MyTrue = 'True {# LANGUAGE NoDataKinds #} module B where import A import Data.Proxy f :: Proxy MyTrue f = Proxy
GHC will accept the type signature for
f
even thoughDataKinds
is not enabled, as the promoted data constructorTrue
is tucked underneath theMyTrue
type synonym. If the user had writtenProxy 'True
directly, however, thenDataKinds
would be required.In a kind context:
DataKinds
applies to all types mentioned in the kind, including the expansions of type synonyms. For instance, given this module:module C where type MyType = Type type MySymbol = Symbol
We would accept or reject the following definitions in this module, which makes use of Standalone kind signatures and polymorphic recursion:
{# LANGUAGE NoDataKinds #} module D where import C  ACCEPTED: The kind only mentions Type, which doesn't require DataKinds type D1 :: Type > Type data D1 a  REJECTED: The kind mentions Symbol, which requires DataKinds to use in  a kind position data D2 :: Symbol > Type data D2 a  ACCEPTED: The kind mentions a type synonym MyType that expands to  Type, which doesn't require DataKinds data D3 :: MyType > Type data D3 a  REJECTED: The kind mentions a type synonym MySymbol that expands to  Symbol, which requires DataKinds to use in a kind position data D4 :: MySymbol > Type data D4 a
6.4.11. Unique syntax for typelevel lists and tuples¶

ListTuplePuns
¶ Since: 9.10.1 Accept bracket syntax to denote type constructors, using single quotes to disambiguate data constructors.
The previously defined mechanism for specifying data constructors with bracket syntax and single quotes is governed by this extension, which is enabled by default.
With NoListTuplePuns
, brackets are unambiguously parsed as data
constructors, while the single quote is not accepted as a prefix for them
anymore.
Type constructors cannot be expressed with brackets anymore; instead, new
data type declarations in regular syntax have been added to ghcprim
:
data List a = []  a : List a
data Unit = ()
data Tuple2 a b = (a, b)
data Tuple2# a b = (# a, b #)
data Sum2# a b = (# a  #)  (#  b #)
class (a, b) => CTuple2 a b
instance (c1, c2) => CTuple2 c1 c2
CTuple2 is a constraint tuple, which historically only concerns declarations like:
type C = (Eq Int, Ord String)
These are distinct from the usual specification of multiple constraints on functions or instances with parentheses, since those are treated specially by GHC.
When the extension is disabled, any occurrence of special syntax in types will
be treated as the data constructor, so a type of (Int, String)
has kind
Tuple2 Type Type
, corresponding to the type '(Int, String)
with kind
(Type, Type)
when ListTuplePuns
is enabled.
The explicit disambiguation syntax using single quotes is invalid syntax when the extension is disabled.
The earlier example would need to be rewritten like this:
data HList :: List Type > Type where
HNil :: HList []
HCons :: a > HList t > HList (a : t)
data Tuple :: Tuple2 Type Type > Type where
Tuple :: a > b > Tuple2 a b
foo0 :: HList []
foo0 = HNil
foo1 :: HList [Int]
foo1 = HCons (3 :: Int) HNil
foo2 :: HList [Int, Bool]
foo2 = ...
Constraint tuples may be mixed with conventional syntax:
f ::
Monad m =>
CTuple2 (Monad m) (Monad m) =>
(Monad m, CTuple2 (Monad m) (Monad m)) =>
m Int
f = pure 5
The new type constructors are exported only from the library
ghcexperimental
, by the modules Data.Tuple.Experimental
,
Data.Sum.Experimental
and Prelude.Experimental
.
Please refer to GHC Proposal #475 for the full specification of effects and interactions.