2  definitions  found 
 
  From  The  Free  On-line  Dictionary  of  Computing  (13  Mar  01)  [foldoc]: 
 
  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) 
 
 
 
  From  The  Free  On-line  Dictionary  of  Computing  (13  Mar  01)  [foldoc]: 
 
  tuple 
 
  In  {functional  language}s,  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 
  type}s)  -  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. 
 
 

browse words by letter
a b c d e f g h i j k l m n o p q r s t u v w x y z
or search   thesauri dictionary search words