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].
Tuple elements are accessed using underscore syntax. 'tuple._n' gives nth element(given there are that many elements).
println(ingredient._1) // Sugar
println(ingredient._2) // 25
Sugar 25
Scala tuple also supports destructuring.
val (name, quantity) = ingredient
println(name) // Sugar
println(quantity) // 25
Sugar 25
name: String = "Sugar" quantity: Int = 25
Tuple destructuring can be used in pattern matching too.
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.
val numPairs = List((2, 5), (3, -7), (20, 56))
for ((a, b) <- numPairs) {
println(a * b)
}
10 -21 1120
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