Filter null keys and values from map in Kotlin

Question

I have an extension function that filters away entries with null keys or values:

fun <K, V> Map<K?, V?>.filterNotNull(): Map<K, V> = this.mapNotNull { 
   it.key?.let { key -> 
      it.value?.let { value -> 
         key to value 
      }
   }
}.toMap()

This works for a map with nullable keys and values:

data class Stuff(val foo: Int)

val nullMap = mapOf<String?, Stuff?>(null to (Stuff(1)), "b" to null, "c" to Stuff(3))
assert(nullMap.filterNotNull().map { it.value.foo } == listOf(3))

But not in one that has non-nullable keys or values:

val nullValues = mapOf<String, Stuff?>("a" to null, "b" to Stuff(3))    
assert(nullValues.filterNotNull().map { it.value.foo } == listOf(3))

Type mismatch: inferred type is Map<String, Stuff?> but Map<String?, Stuff?> was expected
Type inference failed. Please try to specify type arguments explicitly.

Is there a way to make my extension function work for both cases, or do I need to provide two separate functions?

score 7 · Accepted Answer · answered Nov 11 '19 at 11:05

7

I will later figure out why, but adding out to the map is working:

fun <K : Any, V : Any> Map<out K?, V?>.filterNotNull(): Map<K, V> = ...

answered Nov 11 '19 at 11:05

tieskedh

327
5
10

2

Thanks! It looks like the `out` keyword was all that I needed, no need for `: Any`. – neu242 Nov 11 '19 at 11:09

score 3 · Answer 2 · answered Nov 14 '19 at 22:42

The solution

fun <K, V> Map<out K?, V?>.filterNotNull(): Map<K, V> = this.mapNotNull {
    it.key?.let { key ->
        it.value?.let { value ->
            key to value
        }
    }
}.toMap()

seems overcomplicated to me. It could be written as

fun <K, V> Map<out K?, V?>.filterNotNull(): Map<K, V> =
    filter { it.key != null && it.value != null } as Map<K, V>

The ugly cast is necessary, since the compiler can not (yet) deduce, that neither keys nor values contain null.

A word of warning, concerning the covariance out K?

Yes, it offers the possibility to use the same method not only for Map<String?, Stuff?> but also for Map<String, Stuff?> (key nullable or not). But this freedom comes with a cost. For maps, known to have no null keys, you needlessly pay the null comparison for every entry.

In your initial solution - that without covariance on K -, the compiler could prevent you from calling that inefficient method. The proper method then probably is

fun <K, V> Map<K, V?>.filterValuesNotNull() = filterValues { it != null } as Map<K, V>

Thanks! I intentionally asked for a function covering *both* null keys and values, so that latter comment is quite useless :) Also, I try to avoid explicit (and ugly) casts (as well as abdominations like `!!`), so using an explicitly safe call like `?.let` is definitely the way to go for me. — neu242, Nov 18 '19 at 08:17

Diego Marin Santos · Answer 3 · 2019-11-14T23:01:58.080

1

You can specify the Map type when using mapOf

assert(mapOf<String?, String?>("x" to null, "a" to "b").filterNotNull() == mapOf("a" to "b"))

EDIT

You specified the extension function for Map<K?, V?> and was trying to use it an inferred Map<String, String> (in your original question), so it wouldn't work as Map<String, String> is not a subtype of Map<K?, V?>, cause map interface is defined as Map<K, out V>. It is invariant on the key parameter type and covariant on the value parameter type.

What you can do is to make the key type in your extension function also covariant by changing Map<K?, V?> to Map<out K?, V?> instead. Now, Map<String, String> or Map<String, String?> will be a subtype of Map<K? V?>.

You can also use a biLet instead two nested let: How can I check 2 conditions using let (or apply etc)

edited Nov 14 '19 at 23:01

answered Nov 11 '19 at 10:51

Diego Marin Santos

1,923
2
15
29

Yes, but I am using this function on maps from various sources. I would have to recreate the map or cast them to `` which kind of defeats the purpose. – neu242 Nov 11 '19 at 11:04
This is what I understand, but why would mapOf().filterNotNull() work? – tieskedh Nov 14 '19 at 11:36
2

Map interface in Kotlin is covariant on the value parameter type. It is defined as Map. – Diego Marin Santos Nov 14 '19 at 16:31

Filter null keys and values from map in Kotlin

3 Answers3