Can we do a conditional chain in Kotlin? or ignore it and go to the next operator? ```private fun s...

# getting-started

[zain]

Can we do a conditional chain in Kotlin? or ignore it and go to the next operator?

private fun simulateFixtures(list: List<List<Team>>) = list.map { fixture ->
    fixture.toList().random()
}.shuffled().chunked(2)

[Sam]

Can you give a bit more detail? Not sure what your example code is trying to convey

[Sam]

My first thought on reading your message is it sounds like a job for Arrow though

[zain]

https://stackoverflow.com/a/69223591/4083142

[Sam]

based on that StackOverflow thread, I would say the canonical solution is something like:

foo.let {
    if (somePredicate) it.doSomething() else it
}

[Sam]

Does that match what you're trying to do? Are you just looking for a shorter way to write it?

[zain]

That matches

[Sam]

I think you'll struggle to find a more concise and readable way to write it than let + `if`/`else`

[Sam]

It is a bit wordy though 😞

[Sam]

The else it on the end is particularly cumbersome

[Joffrey]

What part do you want to run conditionally? All operations look general enough to be done in one go. If you have only 1 fixture in the list passed as argument, you wouldn't even need to call this method, because you would just pick the winner and the result would not be a list or 2-element lists anyway

[Joffrey]

Also, you have a List<List<Team>>, you don't need toList() before using random() on an element. It's already a list, and you don't need a copy just to choose a random element out of it.

[Michael de Kaste]

@Sam well, the kotlin devs have explicitely not added the ternary operator: condition ? onTrue : onFalse

[ephemient]

https://kotlinlang.slack.com/archives/C0B8MA7FA/p1644055755174919?thread_ts=1644007194.532909&cid=C0B8MA7FA

[Arthur Khazbulatov]

If you tend to often write code like:

something
    .let { if (condition1) block1(it) else it }
    .let { if (condition2) block2(it) else it }

I suggest adding these custom scope extension functions to your arsenal:

inline fun <T> T.letIf(condition: Boolean, block: (T) -> T): T =
    if (condition) this.let(block) else this

inline fun <T> T.runIf(condition: Boolean, block: T.() -> T): T =
    if (condition) this.run(block) else this

inline fun <T> T.alsoIf(condition: Boolean, block: (T) -> Unit): T =
    if (condition) this.also(block) else this

inline fun <T> T.applyIf(condition: Boolean, block: T.() -> Unit): T =
    if (condition) this.apply(block) else this

Then you could use them like this:

import my.cool.extensions.letIf

something
    .letIf (condition1) { block1(it) }
    .letIf (condition2) { block2(it) }

[ephemient]

first, a more useful signature would be

inline fun <T : R, R> T.letIf(condition: Boolean, block: (T) -> R): R =
    if (condition) this.let(block) else this

second, that type of extension is waiting for https://youtrack.jetbrains.com/issue/KT-32993