On another topic, Which would you choose? Goal: reassign

filters[property]

if merging two nullable sets yields a non-empty set 1️⃣

val additional: Set<T>? = filterStates[requested]
if (additional is Set<*> && additional.isNotEmpty()) {
    val current: Set<T>? = filters[property]
    if (current is Set<*> && current.isNotEmpty()) {
        filters[property] = current.plus(additional)
    } else {
        filters[property] = additional
    }
}

2️⃣

filters[property].plusMaybe(filterStates[requested.value])?.let {
    filters[property] = it
}

fun <T : Any> Set<T>?.plusMaybe(other: Set<T>?): Set<T>? = (this ?: emptySet()).plus(other ?: emptySet()).takeIf { it.isNotEmpty() }

Why so complicated?

val new = (filterStates[requested] ?: emptySet()) + (filters[property] ?: emptySet())
if (new.isNotEmpty()) {
    filters[property] = new
}

Ahh, that does look pleasing. While it does increase the assignments to

filters[property]

it wouldn’t be an issue in the case of a backing field

How does it increase the assignments?

Currently, if

filterStates[requested]

yields null, it will short circuit from doing the assignment altogether

Ah, true. But that is not in line with the goal you posted 😄

Right, which is why I mentioned it wouldn’t be an issue anyways 🙂