Dependent type

Type systems
Dynamic vs. Static Inferred vs. Manifest Nominal vs. Structural Strong vs. Weak Dependent typing Duck typing Latent typing Substructural typing Type safety Uniqueness typing

In computer science and logic, a dependent type is a type that depends on a value. Dependent types play a central role in intuitionistic type theory and in the design of functional programming languages like ATS, Agda and Epigram.

An example is the type of n-tuples of real numbers. This is a dependent type because the type depends on the value n.

Deciding equality of dependent types in a program may require computations. If arbitrary values are allowed in dependent types, then deciding type equality may involve deciding whether two arbitrary programs produce the same result; hence type checking may become undecidable.

The Curry–Howard correspondence implies that types can be constructed that express arbitrarily complex mathematical properties. If the user can supply a constructive proof that a type is inhabited (i.e., that a value of that type exists) then a compiler can check the proof and convert it into executable computer code that computes the value by carrying out the construction. The proof checking feature makes dependently typed languages closely related to proof assistants. The code-generation aspect provides a powerful approach to formal program verification and proof-carrying code, since the code is derived directly from a mechanically verified mathematical proof.

Systems of the lambda cube

Henk Barendregt developed the lambda cube as a means of classifying type systems along three axes. The eight corners of the resulting cube-shaped diagram each correspond to a type system, with simply typed lambda calculus in the least expressive corner, and calculus of constructions in the most expressive. The three axes of the cube correspond to three different augmentations of the simply typed lambda calculus: the addition of dependent types, the addition of polymorphism, and the addition of higher kinded type constructors (functions from types to types, for example). The lambda cube is generalized further by pure type systems.

First order dependent type theory

The system $\lambda \Pi$ of pure first order dependent types, corresponding to the logical framework LF, is obtained by generalising the function space type of the simply typed lambda calculus to the dependent product type.

Writing $\mbox{Vec}({\mathbb R},n)$ for $n$-tuples of real numbers, as above, $\Pi n:{\mathbb N}.\mbox{Vec}({\mathbb R},n)$ stands for the type of functions which given a natural number n returns a tuple of real numbers of size n. The usual function space arises as a special case when the range type does not actually depend on the input, e.g. $\Pi n:{\mathbb N}.{\mathbb R}$ is the type of functions from natural numbers to the real numbers, written as ${\mathbb N}\to{\mathbb R}$ in the simply typed lambda calculus.

Second order dependent type theory

The system $\lambda \Pi 2$ of second order dependent types is obtained from $\lambda \Pi$ by allowing quantification over type constructors. In this theory the dependent product operator subsumes both the $\to$ operator of simply typed lambda calculus and the $\forall$ binder of System F.

Higher order dependently typed polymorphic lambda calculus

The higher order system $\lambda \Pi \omega$ extends $\lambda \Pi 2$ to all four forms of abstraction from the lambda cube: functions from terms to terms, types to types, terms to types and types to terms. The system corresponds to the Calculus of constructions whose derivative, the calculus of inductive constructions is the underlying system of the Coq proof assistant.

Object-oriented programming

Some recent research has been directed at combining dependent type theory with object-oriented programming.

Comparison

See also: Proof assistant#Comparison

Language	Actively developed	Paradigm	Tactics	Proof terms	Termination checking	Types can depend on	Universes	Proof irrelevance	Program extraction	Extraction erases irrelevant terms
Agda	Yes	Purely functional	Few/limited	Yes	Yes (optional)	Any term	Yes (optional)	Proof-irrelevant arguments (experimental)	Haskell, Javascript	Yes
ATS	Yes	Functional / imperative	No	Yes	Yes	?	?	?	Yes	?
Cayenne	No	Purely functional	No	Yes	No	Any term	No	No	?	?
Coq	Yes	Purely functional	Yes	Yes	Yes	Any term	Yes	No	Haskell, Scheme and OCaml	Yes
Dependent ML	No	?	?	Yes	?	Natural numbers	?	?	?	?
Epigram 2	Yes	Purely functional	No	Coming soon	By construction	Any term	Coming soon	Coming soon	Coming soon	Coming soon
Guru	No	Purely functional	hypjoin	Yes	Yes	Any term	No	Yes	Carraway	Yes
Idris	Yes	Purely functional	Yes	Yes	Yes (optional)	Any term	No	No	Yes	Yes, aggressively
Matita	Yes	Purely functional	Yes	Yes	Yes	Any term	Yes	?	OCaml	?
NuPRL	No	Purely functional	Yes	Yes	Yes	Any term	Yes	?	Yes	?
F*	Yes	Functional /imperative	?	?	?	?	?	?	?	?
PVS	Yes	?	Yes	?	?	?	?	?	?	?
Typed Racket	Yes	No	?	?	?	?	?	?	?	?
Sage	?	Hybrid typechecking	?	?	?	?	?	?	?	?
Twelf	Yes	Logic programming	?	Yes	Yes (optional)	Any (LF) term	No	No	?	?
Xanadu	No	Imperative	?	?	?	?	?	?	?	?

See also

• Typed lambda calculus
• Design by contract

Further reading

• Martin-Löf, Per (1984). Intuitionistic Type Theory. Bibliopolis. 
• Nordström, Bengt; Petersson, Kent; Smith, Jan M. (1990). Programming in Martin-Löf's Type Theory: An Introduction. Oxford University Press. 
• Barendregt, Henk (1992). "Lambda calculi with types". In S. Abramsky, D. Gabbay and T. Maibaum. Handbook of Logic in Computer Science. Oxford Science Publications. 
• McBride, Conor; McKinna, James (January 2004). "The view from the left". Journal of Functional Programming 14 (1): 69–111. 
• Altenkirch, Thorsten; McBride, Conor; McKinna, James (April 2005). Why dependent types matter. 
• Norell, Ulf. Towards a practical programming language based on dependent type theory. PhD thesis, Department of Computer Science and Engineering, Chalmers University of Technology, SE-412 96 Göteborg, Sweden, September 2007.
• Oury, Nicolas and Swierstra, Wouter (2008). "The Power of Pi". Accepted for presentation at ICFP, 2008.
• Norell, Ulf (2008). Dependently Typed Programming in Agda.

External

• Dependently Typed Programming 2008
• Dependently Typed Programming 2010
• Dependently Typed Programming 2011
• "Dependent type" at the Haskell Wiki