since something like this doesn’t work in kotlin ...

# announcements

[William Reed]

since something like this doesn’t work in kotlin

var a = true
var b = false
when (a, b) {
   true, true -> ...
   true, false -> ...
   false, true -> ...
   false, false -> ...
}

is this the best alternative?

when {
   a, !b -> ...
}

[William Reed]

also the first example probably isn’t the most readable with boolean values tossed in

[Nir]

you could make a and b into a pair and then match on that

[William Reed]

good idea

[darkmoon_uk]

var a = true
var b = false
when (a to b) {
   true to true -> ...
   true to false -> ...
   false to true -> ...
   false to false -> ...
   else -> throw Exception("Unhandled a/b combo")
}

...sadly some else handling required, but other than that, aesthetic change is quite small

[Vadim Kapustin]

without else:
we can make enum class

enum class BooleanPair(val a: Boolean, val b: Boolean) {
    TrueTrue(true, true), TrueFalse(true, false),
    FalseTrue(false, true), FalseFalse(false, false);

    companion object {
        operator fun invoke(a: Boolean, b: Boolean) = values().first {
            it.a == a && it.b == b
        }
    }
}

and then

when (BooleanPair(a, b)) {
    BooleanPair.TrueTrue -> ...
    BooleanPair.TrueFalse -> ...
    BooleanPair.FalseTrue -> ...
    BooleanPair.FalseFalse -> ...
}

[CLOVIS]

What are you trying to do exactly? All of this seems over-engineered

[darkmoon_uk]

@CLOVIS Although I made one of the suggestions above, I agree with you. Surely this good old if pattern can't be beaten for simplicity and efficiency?

if(a) {
    if(b) {
        // true, true case
    } else {
        // true, false case
    }
} else {
    if(b) {
        // false, true case
    } else {
        // false, false case
    }
}

[CLOVIS]

Exactly. Maybe there's even a simpler solution, but we'd need to know more of the context.

[CLOVIS]

Honestly even

when {
  a && b ->
  a && !b ->
  !a && b ->
  !a && !b ->
}

is simple, short, and readable. Sure, it's not pattern matching and it's a little bit of boilerplate, but it's damn efficient and you probably don't need to write this often.

If you do need to write this often, maybe there's another thing to be simplified elsewhere.