# Generalized algebraic data type

Jump to: navigation, search

In functional programming, a generalized algebraic data type (GADT, also first-class phantom type,[1] guarded recursive datatype,[2] or equality-qualified type[3]) is a generalization of the algebraic data types of Haskell and ML, applying to parametric types.

With this extension, the parameters of the return type of a data constructor can be freely chosen when declaring the constructor, while for algebraic data types in Haskell 98, the type parameter of the return value is inferred from data types of parameters; they are currently implemented in the GHC compiler as a non-standard extension, used by, among others, Pugs and Darcs. The Omega programming language extends Haskell with generalized algebraic data types. OCaml supports GADT natively since version 4.00.[4]

## History

An early version of generalized algebraic data types were given in (Augustsson & Petersson 1994) and based on pattern matching in ALF.

Generalized algebraic data types were introduced independently by (Cheney & Hinze 2003) and prior by (Xi, Chen & Chen 2003) as extensions to ML's and Haskell's algebraic data types.[5] Both are essentially equivalent to each other. They are similar to the inductive families of data types (or inductive datatypes) found in Coq's Calculus of Inductive Constructions and other dependently-typed languages, modulo the dependent types and except that the latter have an additional positivity restriction which is not enforced in GADTs.[6]

(Sulzmann, Wazny & Stuckey 2006) introduced extended algebraic data types which combine GADTs together with the existential data types and type class constraints introduced by (Perry 1991), (Läufer & Odersky 1994) and (Läufer 1996).

Type inference in the absence of any programmer supplied type annotations is undecidable[7] and functions defined over GADTs do not admit principal types in general.[8] Type reconstruction requires several design trade-offs and is on-going research (Peyton Jones, Washburn & Weirich 2004; Peyton Jones et al. 2006; Pottier & Régis-Gianas 2006; Sulzmann, Schrijvers & Stuckey 2006; Simonet & Pottier 2007; Schrijvers et al. 2009; Lin & Sheard 2010a; Lin & Sheard 2010b; Vytiniotis, Peyton Jones & Schrijvers 2010; Vytiniotis et al. 2011).

## Features

Non-uniform return parameter type
Existentially quantified type parameters
Local constraints

## Applications

Applications of GADTs include generic programming, modelling programming languages (higher-order abstract syntax), maintaining invariants in data structures, expressing constraints in embedded domain-specific languages, and modelling objects.[9]

### Higher-order abstract syntax

An important application of GADTs is to embed higher-order abstract syntax in a type safe fashion. Here is an embedding of the simply-typed lambda calculus with an arbitrary collection of base types, tuples and a fixed point combinator:

```data Lam :: * -> * where
Lift :: a                     -> Lam a
Tup  :: Lam a -> Lam b        -> Lam (a, b)
Lam  :: (Lam a -> Lam b)      -> Lam (a -> b)
App  :: Lam (a -> b) -> Lam a -> Lam b
Fix  :: Lam (a -> a)          -> Lam a
```

And a type safe evaluation function:

```eval :: Lam t -> t
eval (Lift v)    = v
eval (Tup e1 e2) = (eval e1, eval e2)
eval (Lam f)     = \x -> eval (f (Lift x))
eval (App e1 e2) = (eval e1) (eval e2)
eval (Fix f)     = (eval f) (eval (Fix f))
```

The factorial function can now be written as:

```fact = Fix (Lam (\f -> Lam (\y -> Lift (if eval y == 0 then 1 else eval y * (eval f) (eval y - 1)))))
```

We would have run into problems using regular algebraic data types. Dropping the type parameter would have made the lifted base types existentially quantified, making it impossible to write the evaluator. With a type parameter we would still be restricted to a single base type. Furthermore, ill-formed expressions such as `App (Lam (\x -> Lam (\y -> App x y))) (Lift True)` would have been possible to construct, while they are type incorrect using the GADT.

## Further reading

Applications
Semantics
• Patricia Johann and Neil Ghani (2008). "Foundations for Structured Programming with GADTs".
• Arie Middelkoop, Atze Dijkstra and S. Doaitse Swierstra (2011). "A lean specification for GADTs: system F with first-class equality proofs". Higher-Order and Symbolic Computation.
Type reconstruction
Other
• Andrew Kennedy and Claudio V. Russo. "Generalized algebraic data types and object-oriented programming". In Proceedings of the 20th annual ACM SIGPLAN conference on Object oriented programming, systems, languages, and applications. ACM Press, 2005.