[1] : The Free On-line Dictionary of Computing (27 SEP 03)

tuple
     
        toyohashi university parallel lisp environment.  a parallel
        lisp based on kcl.
     
        "memory management and garbage collection of an extended
        common lisp system for massively parallel simd architecture",
        taiichi yuasa, in memory management, iwmm92, springer 1992,
        490-507.
     
        1994-11-08
     
     

[2] : The Free On-line Dictionary of Computing (27 SEP 03)

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.
     
     
see also:
functional language haskell lifted pattern matching algebraic data type miranda 
irrefutable strict 

Tuple >> T Words
Tuple, definition of term: Tuple
tuple_pag1.html