A modern programming language that makes developers happier.

kotlinlang

Hi,
It would be nice that extension functions such us `inline fun &lt;T&gt; T.takeUnless` would work lazily and short circuit code execution if condition is true, kind of lazy evaluation of `previous expression`. What's your thoughts? Is it possible at all?

what should be done lazy? I’m not sure how is that possible for such function

T already there and it must be returned immidiately

because predicate requires T it cannot be lazy

but you can write own extension that doesn’t require eager receiver and just have additional lambda that computes lazily

But it will not be takeUnless anymore semantically

I am not sure what do you mean by
&gt; kind of lazy evaluation of `previous expression`
`takeUnless` returns `null` if condition is `true`.

But I guess what you want is just
```if (condition) null else foo()```
Soo `foo()` is evaluated only if condition is `false`.

And of course you can create extension function with a condition as a receiver, if it makes sense for you.

yeah, after  closer inspection I've noticed that `takeUnless` passes a value into predicate function

and I, until today, I've used it as if(condition) null else codeblock() replacement

I've replaced it with extension function as suggested
`    fun &lt;T&gt; takeUnless(predicate: Boolean, block: () -&gt; T): T? = if (!predicate) block() else null`

at first I just thought if it's inline fun then it will be inlined in code, and will wrap (somehow) expression/variable on which it was called

my case is
```
                val event = GeneratedEvent(
                    on = true,
                    timestamp = randomize(randomSeed, max(visibleRange.start, interval.start - RandomizationRange), interval.start),
                    totalVehicleMiles = dutyEvent.totalVehicleMiles
                ).takeUnless { interval.start == visibleRange.start }
```

as this code was written before, and the special condition just emerged after requirements change

so writing "takeUnless" on the end looked as fastest solution :slightly_smiling_face:

why not just:
```val event = if (interval.start != visibleRange.start) {
 GeneratedEvent(…)
} else {
  null
}```

takeUnless without receiver looks really strange

actually in production code there is a listOf(
  ...,
 ...,
 ...,
 ...
).filterNotNull()

yes, I've misused takeUnless, I'd haven't thought that its predicate function receives value as argument and used as just kind of  generic "convert to null if {any expression is true}"

will change my behaviour from now :slightly_smiling_face:

I used to declare an extension function like Boolean.ifTrue { } 
Which works like also but only if it's true... just not a fan of the name