Destructuring

A handy feature in Kotlin is the ability to destructure datatypes into multiple variables. Given a data class Country:

And an instance country of Country:

We can use the syntax called destructuring declaration to extract the values of name, population and area from country, where the left-hand side of the assignment are comma separated variables wrapped in parentheses:

With this syntax, it is possible to assign multiple variables from properties of a single instance of an object, in one line. This code would give the same result without using destructuring declaration:

The variable names does not have to be the same as the names of the properties of the data class, and we can also specify the types like for regular variable assignments:

Destructuring declaration should not be confused with tuples found in other languages such as Python, Haskell, Scala and C#. While the syntax of destructuring declaration on the left-hand side looks very similar to tuples on the right-hand side, Kotlin does not have tuples. Here is an example to illustrate the similarity:

However, data classes can be seen as powerful tuples with the advantage of both being named themselves as well as their properties.

But how does the destructuring work? It is based on a convention of functions called component1(), component2(), ..., componentN(), where in the assignment val (v1, v2, ..., vN) = x, v1 would be assigned to x.component1(), v2 to x.component2() and so on. These functions are automatically generated for data classes, and would look like the following for the data class Country as extension functions:

This means that we can get destructuring capabilities on any data types, by defining componentN() functions. When destructuring, we can destructure as many, or few, variables as we like, as long as there are defined enough componentN() functions. So if we are not interested in the area variable of country, we can omit area in the destructuring:

If we are only interested in the population variable of country, we can replace the variable name for assigning name with an underscore:

Another useful case of destructuring found in the standard library is on lists, where component1() to component5() functions are defined, making it possible to destructure lists like this:

One should however be sure not to destructure more elements than the list contains, to avoid IndexOutOfBoundsException.

Destructuring can also be used in lambdas. So this lambda, printing the population property of country:

Could also be written like this:

Destructuring is one useful feature in Kotlin that contributes to keeping our code clean and concise. In the future, maybe we will see additional destructuring capabilities in Kotlin, like this proposal for pattern matching using the when expression.