Destructuring in Kotlin

Introduction

This is a process in which we can be able to extract properties of interest from an object  / collection.

We have been used to using destructuring in javascript and other functional languages whereas in Java / C# we have not been able to do this.

However, kotlin has added the functionality to destructure classes by properties, collections, maps etc.

Destructuring classes

To enable a class to be destructured, should we do anything in kotlin?

The answer is yes and no.. looks puzzling ain't it.

Destructuring a class

Below is a regular class (non data class) which needs implementation to allow it to be destructured

class User(var mail: String, var deptId: Long) {
    operator fun component1() = mail
    operator fun component2() = deptId
}

Destructuring a data class

Below is a declaration of a data class which comes with the support for destructuring for free as like toString, hashcode etc..

data class CompanyUser(var mail: String, var deptId: Long)

Now that pre-requisites are covered, let's move to destructuring, shall we

Destructuring to tuples

Let's say that we need to extract the email, department from the above class, we must implement as given below,

var (mail, dept) = users.get(0);
println(mail)
println(dept)

Here, we have taken the 1st user and extracted out the mail and dept properties and printed them to the console.

Destructuring collections

Below is an example of a list of users created and how we can extract the objects from the list, this is not quite great of an example, but helps explain the concept 

var users = listOf(
    User("admin@company.com", 0),
    User("manager@company.com", 1),
    User("developer1@company.com", 2),
    User("dev2@company.com", 2)
)

We are extracting the admin and manager users from the list as given below

val (admin, mgr) = users
println(admin)
println(mgr)

Destructuring a map

In the maps, we normally have keys and values and we use a Pair in Kotlin to process or Map.Entry in java to process. In case of applying destructuring, it boils down to tuples with less code

Map:

var userMap = mapOf(
    users.get(0).deptId to users.get(0),
    users.get(1).deptId to users.get(1),
    users.get(2).deptId to users.get(2)
)

Now the destructuring is as given below

for ((k, v) in userMap) println("$k - $v")

Caution

Let us assume that we plan to implement a destructuring operation in an array which might be coming as an input from another application or from a 3rd party library, we need to make sure that the bounds are checked.

val (first, second, third, fourth) = arrayOf(1, 2, 3)

Now, let us explore the destructuring operation

println("$first ~ $second ~ $third")

A working desctructing is given above 

println("$first ~ $second ~ $third ~ $fourth")

As we have learned about the nullable types, we might assume that the nullable type can help evade the Array Index out of bounds exception, which will not be working as given below

val (first, second, third, fourth: Int?) = arrayOf(1, 2, 3)

This again throws an exception instead of setting fourth as null.