Is there any way to "return" fast in when expressi...

# getting-started

[Loney Chou]

Is there any way to "return" fast in when expressions? Don't like the fact that I need another indent for c.

val foo = when {
    condition1 -> a
    condition2 -> {
        if (condition3) {
            break b // Here
        }
        // Long code
        c
    }
    else -> d
}

[Jeff Lockhart]

Just use an else:

val foo = when {
    condition1 -> a
    condition2 -> {
        if (condition3) {
            b // Here
        } else {
            // Long code
            c
        }
    }
    else -> d
}

I'd break out the complexities of "long code" into a separate function as well.

[Loney Chou]

Seems like I can't do `yield b`like Java. 😥

[Jeff Lockhart]

Kotlin doesn't need yield because when and if statements are already expressions. As long as each of your branches produces a proper value for foo, the code I just shared works for what you described. foo will equal a, b, c, or d, depending on the outcome of condition1, condition2, or condition3.

[sciack]

you can also do:

val foo = when {
    condition1 -> a
    condition2 && condition3 -> b
    condition2 ->
            // Long code
            c
    else -> d
}

[sciack]

also try to keep what is in each condition as small as possible (ideally call a function if you need a long code)

[Loney Chou]

I think I'll go condition2 && condition3 followed by another condition2 then. Not hurt that much.

[sciack]

also check IJ suggestion, I found them very useful

[Klitos Kyriacou]

Also possible, but not recommended as it makes the code more obscure:

val foo = run {
    when {
        condition1 -> a
        condition2 -> {
            if (condition3) {
                return@run b
            }
            // Long code
            c
        }
        else -> d
    }
}

(Also, it defeats the purpose as it adds an extra level of indentation, which is exactly what you're trying to avoid.)

[ephemient]

you don't need extra indentation if you do it the other way around

val foo = when {
    condition1 -> a
    condition2 -> run {
        if (condition3) {
            return@run b
        }
        // Long code
        c
    }
    else -> d
}

[Loney Chou]

"`run` ftw" does't quite fit in my taste though...I'm OK with condition2 && condition3 because it's better than having two possible values yielded in a single when branch. That second condition2 acts like a fallback so it doesn't break the intent.

[Klitos Kyriacou]

As long as condition2 doesn't have any side effects and doesn't take a long time to compute, there's no harm in repeating it.

[Jeff Lockhart]

Or compute it before the when and just use the boolean result.

[Wout Werkman]

@Jeff Lockhart, that might be too eager in case condition1 is true 🙂. There is no one size fits all solution

[Jeff Lockhart]

Oh yes, true. Definitely not a one size fits all here.