Component destructuring with fewer than expected components

Question

Let's say I want to do the following:

val (k, v) = pair.split("=".toRegex(), 2)

This code is fine if I always get 2 components from the split - however, if the delimiter is not present in the string, this code throws an exception, because the second element in the array isn't present.

The answer is almost certainly "no", but is there some way to coerce destructure to assign null values to missing components?

Answer 1

When destructuring objects, Kotlin calls componentN() for that object. For arrays, component1() is equal to get(0), component2() is equal to get(1), and so on.

So if the index is out of bounds, it'll throw ArrayIndexOutOfBoundsException, instead of returning null.

---

But you can make your operator function like this:

operator fun <T> Array<out T>.component1(): T? = if (size > 0) get(0) else null
operator fun <T> Array<out T>.component2(): T? = if (size > 1) get(1) else null

so if I run

val (k, v) = arrayOf(1)

println(k)
println(v)

the output will be

1
null

---

See:

• Destructuring Declarations

Answer 2

You could add your own extension to List that adds the required number of null values to the end:

val (k, v) = pair.split("=".toRegex(), 2).padWithNulls(limit = 2)

Implementation can be done a couple of ways, here's just one:

private inline fun <reified E> List<E>.padWithNulls(limit: Int): List<E?> {
    if (this.size >= limit) {
        return this
    }

    val result: MutableList<E?> = this.toMutableList()
    result.addAll(arrayOfNulls(limit - this.size))
    return result
}

Here's a simpler one as well:

private fun <E> List<E>.padWithNulls(limit: Int): List<E?> {
    val result: MutableList<E?> = this.toMutableList()

    while (result.size < limit) {
        result.add(null)
    }

    return result
}

---

Or wrapping this functionality even further:

val (k, v) = pair.splitAndPadWithNulls("=".toRegex(), 2)

private fun String.splitAndPadWithNulls(regex: Regex, limit: Int): List<String?> {
    return this.split(regex, limit).padWithNulls(limit)
}