A modern programming language that makes developers happier.

kotlinlang

image.png

wouldnt such a syntax be more convenient?

```val (first, second!!) = Pair&lt;String, String?&gt;("not null", "same")

// so I dont have to:
val (first, second) = Pair&lt;String, String?&gt;("not null", "same")
// and then
val secondNotNull = second!!```

Too esoteric to complicate the language. If the return value is never null it should not be marked as being nullable, and if it can be null then the caller should not ignore it.

Instead of `val secondNotNull = second!!`, all you have to do is `second!!` by itself on the next line, and then just use `second` (smart cast).
Alternatively, `val (first, second) = foo() as Pair&lt;String, String&gt;` but you'll get a warning.

<@U9TRSCYSF> The value IS null when the special flag is set to false. But it is NEVER null when the flag is set to true

<@U01MQG40ZNC> Yeah, right. But the problem is that I don't want to use `!!`  each time I access the variable. It's not a big problem to consume a nullable value and use `!!`  once.

That's what I'm saying - just use `second!!` once. Not every time you access it.

The same works with `requireNotNull` and `checkNotNull` and any other function that defines an appropriate contract:

```val (first, second) = f() // Pair&lt;String, String?&gt;

second!!
requireNotNull(second) { "imposibru!" }
checkNotNull(second) { "impsibru!" }

second // definitely not null here 8)```