The DICT Development Group

Search for:
Search type:

Database copyright information
Server information

2 definitions found
 for tuple
From The Free On-line Dictionary of Computing (30 December 2018) :

  Toyohashi University Parallel Lisp Environment
      (TUPLE) 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,

From The Free On-line Dictionary of Computing (30 December 2018) :

      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 type 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 (where bottom represents non-termination) 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.

Contact=webmaster@dict.org Specification=RFC 2229