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 experimental functional programming languages like Dependent ML and Epigram.
An example is the type of n-tuples of real numbers, which we
may denote as 
.
This is a dependent type because the type depends on the
value 
.
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 becomes 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 then 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.
Contents |
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.
The system λP 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
for n-tuples of real
numbers, as above, 
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. 
is the type of functions from natural numbers to the real numbers,
written as 
in the simply typed lambda calculus.
The system λP2 of second order
dependent types is obtained from λP by
allowing quantification over type constructors. In this theory the
dependent product operator subsumes both the 
operator of simply typed lambda calculus and the 
binder of System F.
The higher order system λPω extends λP2 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.
Some recent research (Setzer 2007) has been directed at combining dependent type theory with object-oriented programming.
H. Barendregt (1992). "Lambda calculi with types". in S. Abramsky, D. Gabbay and T. Maibaum. Handbook of Logic in Computer Science. Oxford Science Publications. ftp://ftp.cs.ru.nl/pub/CompMath.Found/HBK.ps.
Anton Setzer (2007). "Object-oriented programming in dependent type theory". in Henrik Nilsson. Trends in Functional Programming, vol. 7. Intellect. pp. 91–108. http://www.cs.swan.ac.uk/~csetzer/articles/objectOrientedProgrammingInDepTypeTheoryTfp2006PostProceedings.pdf.
   | Sage Programming Language - Sage: A Programming Language with Hybrid Type-Checking |
| | Xanadu - Xanadu: Imperative Programming with Dependent Types |
| | ATS - Home Page for ATS |
|
|
Wikis
Quiz
Search
