Tour of Scala


In Scala, a tuple is a class that can hold elements of different types. Tuples are immutable.

Tuples come in handy when we have to return multiple values from a function.

A tuple can be created as:

In [1]:
val ingredient = ("Sugar" , 25):Tuple2[String, Int]
ingredient: (String, Int) = ("Sugar", 25)

This creates a tuple containing a String element and an Int element.

Tuple in Scala is a series of classes: Tuple2, Tuple3, etc., through Tuple22. So when we create a tuple with n elements(n lying between 2 and 22), Scala basically instantiates one of the corresponding classes from the group, parameterized with types of constituent elements. For eg., ingredient is of type Tuple2[String, Int].

Accessing the elements

Tuple elements are accessed using underscore syntax. 'tuple._n' gives nth element(given there are that many elements).

In [2]:
println(ingredient._1) // Sugar

println(ingredient._2) // 25

Destructuring tuple data

Scala tuple also supports destructuring.

In [3]:
val (name, quantity) = ingredient

println(name) // Sugar

println(quantity) // 25
name: String = "Sugar"
quantity: Int = 25

Tuple destructuring can be used in pattern matching too.

In [4]:
val planetDistanceFromSun = List(("Mercury", 57.9), ("Venus", 108.2), ("Earth", 149.6 ), ("Mars", 227.9), ("Jupiter", 778.3))

planetDistanceFromSun.foreach{ tuple => {
  tuple match {
      case ("Mercury", distance) => println(s"Mercury is $distance millions km far from Sun")
      case p if(p._1 == "Venus") => println(s"Venus is ${p._2} millions km far from Sun")
      case p if(p._1 == "Earth") => println(s"Blue planet is ${p._2} millions km far from Sun")
      case _ => println("Too far....")
Mercury is 57.9 millions km far from Sun
Venus is 108.2 millions km far from Sun
Blue planet is 149.6 millions km far from Sun
Too far....
Too far....
planetDistanceFromSun: List[(String, Double)] = List(
  ("Mercury", 57.9),
  ("Venus", 108.2),
  ("Earth", 149.6),
  ("Mars", 227.9),
  ("Jupiter", 778.3)

Or, in 'for' comprehension.

In [5]:
val numPairs = List((2, 5), (3, -7), (20, 56))

for ((a, b) <- numPairs) {

  println(a * b)
numPairs: List[(Int, Int)] = List((2, 5), (3, -7), (20, 56))

The value () of type Unit is conceptually the same as the value () of type Tuple0. There can only be one value of this type since it has no elements.

Users may sometimes find hard to choose between Tuples and case classes. As a rule, case classes are preferred choice if elements carry more meaning.



Tour of Scala