Scala Tuples
Examples
Creating a new Tuple
A tuple is a heterogeneous collection of two to twenty-two values. A tuple can be defined using parentheses. For tuples of size 2 (also called a 'pair') there's an arrow syntax.
scala> val x = (1, "hello")
x: (Int, String) = (1,hello)
scala> val y = 2 -> "world"
y: (Int, String) = (2,world)
scala> val z = 3 → "foo" //example of using U+2192 RIGHTWARD ARROW
z: (Int, String) = (3,foo)x is a tuple of size two. To access the elements of a tuple use ._1, through ._22. For instance, we can use x._1 to access the first element of the x tuple. x._2 accesses the second element. More elegantly, you can use tuple extractors.
The arrow syntax for creating tuples of size two is primarily used in Maps, which are collections of (key -> value) pairs:
scala> val m = Map[Int, String](2 -> "world")
m: scala.collection.immutable.Map[Int,String] = Map(2 -> world)
scala> m + x
res0: scala.collection.immutable.Map[Int,String] = Map(2 -> world, 1 -> hello)
scala> (m + x).toList
res1: List[(Int, String)] = List((2,world), (1,hello))The syntax for the pair in the map is the arrow syntax, making it clear that 1 is the key and a is the value associated with that key.
Tuples within Collections
Tuples are often used within collections but they must be handled in a specific way. For example, given the following list of tuples:
scala> val l = List(1 -> 2, 2 -> 3, 3 -> 4)
l: List[(Int, Int)] = List((1,2), (2,3), (3,4))It may seem natural to add the elements together using implicit tuple-unpacking:
scala> l.map((e1: Int, e2: Int) => e1 + e2)However this results in the following error:
<console>:9: error: type mismatch;
found : (Int, Int) => Int
required: ((Int, Int)) => ?
l.map((e1: Int, e2: Int) => e1 + e2)Scala cannot implicitly unpack the tuples in this manner. We have two options to fix this map. The first is to use the positional accessors _1 and _2:
scala> l.map(e => e._1 + e._2)
res1: List[Int] = List(3, 5, 7)The other option is to use a case statement to unpack the tuples using pattern matching:
scala> l.map{ case (e1: Int, e2: Int) => e1 + e2}
res2: List[Int] = List(3, 5, 7)These restrictions apply for any higher-order-function applied to a collection of tuples.