A modern programming language that makes developers happier.

kotlinlang

Any better workaround for nullable destructuring?
```val (p1,p2) = pair ?: null to null```


You can make extensions:
```operator fun &lt;T, V&gt; Pair&lt;T, V&gt;?.component1(): T? = null
operator fun &lt;T, V&gt; Pair&lt;T, V&gt;?.component2(): V? = null

val (p1,p2) = pair```
But that'd only work for pair for example. You've to redefine these things for triple, data classes, etc.

I reworked the code and ended up doing this instead:
```pair?.let { (p1,p2) -&gt; 
}```

That last line is a bit unreadable, I think. It is succinct, which is nice — but it’s not straightforward to read. do you need that snippet more than once in the codebase?

if yes, consider extracting the behavior to a function; otherwise, consider changing how you set the “pair” itself

(just like we don’t send back a list as null, but an empty list, a similar idiom may work here where you don’t send back a null pair, but a pair of nulls)

If the situation is recurrent, there’s a case for something like this in the codebase:
```inline fun &lt;T&gt;valueOrDefault(value:T?,default:T):T = value?:default ```
which is easy on the eyes on the calling site

?.let is a totally standard Kotlin idiom so I'm confused why you call it unreadable

the `.let {(p1,p2)-&gt; }` is what I find harder to parse.

or, as I said it earlier — “a bit unreadable”

I dunno, it's really just two pretty standard things combined though, the ?.let and lambda destructuring :shrug:

It’s OK if my point does not make sense to you.