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
}

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.

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

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

.

you can also do:

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

I think I'll go

condition2 && condition3

followed by another

condition2

then. Not hurt that much.

also check IJ suggestion, I found them very useful

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.)

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
}

"`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.

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.

Or compute it before the

when

and just use the boolean result.

@Jeff Lockhart, that might be too eager in case

condition1

is true 🙂. There is no one size fits all solution

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