Kotlin：filterNotNull 用于 Map 中的值<k,v?></k,v?>

Question

Here's the Kotlin code I'd like to write (with extra type annotations for clarity):

fun test(alpha: String, beta: String, gamma: String? = null, delta: String? = null) {
    val r1: Map<String, String?> =
        hashMapOf(
            "alpha" to alpha,
            "beta" to beta,
            "gamma" to gamma,
            "delta" to delta
        )
    val r2: Map<String, String> = r1.filterValues { it != null }
    callSomeFunction(r2)  // expects a parameter of type Map<String, String>
}

Unfortunately, r1.filterValues { it != null } gives me back a Map<String, String?> , not a Map<String, String> . I understand why this is; it's the same reason that listOf(1, null).filter { it != null } has a different type from listOf(1, null).filterNotNull() . However, I still need to solve my problem!

Is there an idiomatic way to "filterValuesNotNull" from a Map ?

Or, stepping up a level, is there some other idiomatic way to say "give me a Map of the following arguments, but skip those whose values are null"? I could resort to this , but I don't want to:

fun test(alpha: String, beta: String, gamma: String? = null, delta: String? = null) {
    var r1: MutableMap<String, String> = mutableMapOf(
        "alpha" to alpha,
        "beta" to beta
    )
    if (gamma != null) {
        r1["gamma"] = gamma
    }
    if (delta != null) {
        r1["delta"] = delta
    }
    callSomeFunction(r1)  // expects a parameter of type Map<String, String>
}

Answer 1

Here's 2 ways to do it, although whether either is idiomatic, I do not know.

@Suppress("UNCHECKED_CAST)
fun filterNotNullUnchecked(map: Map<String, String?>): Map<String, String> =
  map.filterValues { it != null } as Map<String, String>

EDIT: As @Tenfour04 pointed out, this isn't unsafe, just unchecked because of type erasure, and adding a Suppress("UNCHECKED_CAST) annotation makes the warning go away.

fun filterNotNullUgly(map: Map<String, String?>): Map<String, String> {
  val map2 = HashMap<String, String>()
  for ((k, v) in map) if (v != null) map2[k] = v
  return map2
}

Answer 2

The functions that in my opinion should be in the stdlib:

fun <K,V: Any> Map<K,V?>.filterNotNullValuesTo(destination: MutableMap<K,V>): Map<K, V> {
    for ((key, value) in entries) if (value != null) destination[key] = value
    return destination
}

fun <K,V: Any> Map<K,V?>.filterNotNullValues(): Map<K,V> = filterNotNullValuesTo(mutableMapOf())

Answer 3

hm, I suppose, it can be decided on that way

val newMap: Map<String, String> = r1.mapNotNull { (key, value) ->
    value?.let { key to it }
}.toMap()