tuple
In functional languages, a data object containing two or more components. Also
known as a product type or pair, triple, quad, etc. Tuples of different sizes
have different types, in contrast to lists where the type is independent of the
length. The components of a tuple may be of different types whereas all elements
of a list have the same type. Examples of tuples in Haskell notation are (1,2),
("Tuple",True), (w,(x,y),z). The degenerate tuple with zero components, written
(), is known as the unit type since it has only one possible value which is also
written ().
The implementation of tuples in a language may be either "lifted" or not. If
tuples are lifted then (bottom,bottom) /= bottom and the evaluation of a tuple
may fail to terminate. E.g. in Haskell:
f (x,y) = 1 --> f bottom = bottom
f (bottom,bottom) = 1
With lifted tuples, a tuple pattern is refutable. Thus in Haskell, pattern
matching on tuples is the same as pattern matching
on types with multiple constructors (algebraic data
types) - the expression being matched is evaluated
as far as the top level constructor, even though, in
the case of tuples, there is only one possible
constructor for a given type.
If tuples are unlifted then (bottom, bottom) = bottom and evaluation of a tuple
will never fail to terminate though any of the components may. E.g. in Miranda:
f (x,y) = 1 --> f bottom = 1
f (bottom,bottom) = 1
Thus in Miranda, any object whose type is compatible with a tuple pattern
is assumed to match at the top level without
evaluation - it is an irrefutable pattern. This also
applies to user defined data types with only one
constructor. In Haskell, patterns can be made
irrefutable by adding a "~" as in
f ~(x,y) = 1.
If tuple constructor functions were strict in all their arguments then
(bottom,x) = (x,bottom) = bottom for any x so
matching a refutable pattern would fail to terminate
if any component was bottom.
Nearby terms:
tune « tunnelling « TUPLE « tuple » tuple
calculus » Tuple Space Smalltalk » tupling
|
