Tuples

A tuple is a neat class that gives you a simple way to store heterogeneous (different) items in the same container. For example, assuming that you have a class like this:

class Person(var name: String) 

Instead of having to create an ad-hoc class to store things in, like this:

class SomeThings(i: Int, s: String, p: Person) 

you can just create a tuple like this:

val t = (3, "Three", new Person("Al")) 

As shown, just put some elements inside parentheses, and you have a tuple. Scala tuples can contain between two and 22 items, and they’re useful for those times when you just need to combine a few things together, and don’t want the baggage of having to define a class, especially when that class feels a little “artificial” or phony.

Technically, Scala 2.x has classes named Tuple2, Tuple3 … up to Tuple22. As a practical matter you rarely need to know this, but it’s also good to know what’s going on under the hood. (And this architecture is being improved in Scala 3.)

A few more tuple details

Here’s a two-element tuple:

scala> val d = ("Maggie", 30) d: (String, Int) = (Maggie,30) 

Notice that it contains two different types. Here’s a three-element tuple:

scala> case class Person(name: String) defined class Person scala> val t = (3, "Three", new Person("David")) t: (Int, java.lang.String, Person) = (3,Three,Person(David)) 

There are a few ways to access tuple elements. One approach is to access them by element number, where the number is preceded by an underscore:

scala> t._1 res1: Int = 3 scala> t._2 res2: java.lang.String = Three scala> t._3 res3: Person = Person(David) 

Another cool approach is to access them like this:

scala> val(x, y, z) = (3, "Three", new Person("David")) x: Int = 3 y: String = Three z: Person = Person(David) 

Technically this approach involves a form of pattern-matching, and it’s a great way to assign tuple elements to variables.

Returning a tuple from a method

A place where this is nice is when you want to return multiple values from a method. For example, here’s a method that returns a tuple:

def getStockInfo = { // other code here ... ("NFLX", 100.00, 101.00) // this is a Tuple3 } 

Now you can call that method and assign variable names to the return values:

val (symbol, currentPrice, bidPrice) = getStockInfo 

The REPL demonstrates how this works:

scala> val (symbol, currentPrice, bidPrice) = getStockInfo symbol: String = NFLX currentPrice: Double = 100.0 bidPrice: Double = 101.0 

For cases like this where it feels like overkill to create a class for the method’s return type, a tuple is very convenient.

Tuples aren’t collections

Technically, Scala 2.x tuples aren’t collections classes, they’re just a convenient little container. Because they aren’t a collection, they don’t have methods like map, filter, etc.