Tuples are (not?) Collections

Tuples are quite handy but a potential annoyance is that at a glance they seem list-like but appearances can be deceiving. The normal collection methods are not supported by Tuples. For example suppose you like the simple syntax: (1,2,3) better than List(1,2,3). With the Tuple you cannot do the maps, filters, etc... (with good reason) but there is a use-case for being able to convert a Tuple to a Traversable.

Word of warning. Unlike collections Tuples are very often not homogeneous. IE you do not have Tuple2[Int] you have Tuple2[A,B]. So the best you can do is to map a tuple to an Iterator[Any].

Note: this was done with Scala 2.8 so results may be slightly different with 2.7. But I believe the syntax is valid.

1. // the productIterator method gives access to an iterator over the elements
2. scala> (1,2,3).productIterator.map {_.toString} mkString (",")
3. res1: String = 1,2,3
5. scala> (1,2,3).productIterator foreach {println _}            
6. 1
7. 2
8. 3
10. // if you know the tuple is heterogeneous then you can use partial functions
11. // for casting the elements to a particular type.  
12. scala> (1,2,3).productIterator map {case i:Int => i + 2} foreach {println _}
13. 3
14. 4
15. 5
17. // To get a full Traversable out of the deal you use one of the many
18. // to* methods to convert to Seq, List, Array, etc...
19. scala> (1,2,3).productIterator.toList map {case i:Int => i + 2}      
20. res15: List[Int] = List(3, 4, 5)
22. // and if you want you can use an implicit to clean up the syntax a bit
24. // Problem with this is you need an implicit for each Tuple length
25. scala> implicit def tupleToTraversable[T](t:(T,T,T)) = t.productIterator.toList map { case e:T => e}
26. warning: there were unchecked warnings; re-run with -unchecked for details
27. tupleToTraversable: [T](t: (T, T, T))List[T]
29. scala> (1,2,3) foreach {println _}
30. 1
31. 2
32. 3
34. /* 
35. EDIT:  Dan pointed out that the methods I am using are inherited from the
36. Product super class of Tuple.  So you can do something similar as follows.
38. Note:  I am using the same name as the previous method so that they don't interfer 
39. with one another
40. */
41. scala> implicit def tupleToTraversable[T](t:Product) = t.productIterator.toList map { case e:T => e} 
42. warning: there were unchecked warnings; re-run with -unchecked for details
43. tupleToTraversable: [T](t: Product)List[T]
45. scala> (1,2,3) foreach {println _}
46. 1
47. 2
48. 3
50. // this is interesting... it does cast to int unless required
51. scala> (1,2,'t') foreach {println _}
52. 1
53. 2
54. t
56. // lets verify we are getting correct conversion
57. scala> def inc(l:List[Int]) = l map {_ + 1} 
58. inc: (l: List[Int])List[Int]
61. scala> inc ( (1,2,3))                              
62. res4: List[Int] = List(2, 3, 4)
64. // yep this I expected
65. scala> inc ( (1,2,'t'))
66. java.lang.ClassCastException: java.lang.Character cannot be cast to java.lang.Integer
67. at scala.runtime.BoxesRunTime.unboxToInt(Unknown Source)
68. at $anonfun$inc$1.apply(< console>:7)
69. at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:238)
70. at .< clinit>(< console>)
72. scala> def inc(l:List[Int]) = l foreach {println _}
73. inc: (l: List[Int])Unit
75. scala> def p(l:List[Int]) = l foreach {println _}  
76. p: (l: List[Int])Unit
78. scala> p ( (1,2,'t'))                              
79. 1
80. 2
81. t