basically:

val list: List<Pair<String, String>> = listOf(
            "a" to null,
            "b" to "hi"
        )
            .filter {it.second != null}

Not sure if mapNotNull works?

listOf("a" to "b", "c" to null).mapNotNull { if(it.second == null) null else it }

Maybe you would need a

it as Pair<String, String>

but idk

if (it.second == null) null else it

is useless, just use

.mapNotNull { it.second }

right, I need it.first as well though

@Alowaniak the check is doing exactly this 🙂

.mapNotNull { it.second }

would map to the second element, he would indeed lose the

it.first

@Alowaniak your example just asserts that the pair is not null

even when adding

as Pair<String, String>

?

nah, but I suppose I can just cast it anyways

Well you could make a function of it and then do:

fun nonNullPair(from: Pair<String, String?>): Pair<String, String>? {
    return from.first to (from.second ?: return null)
}

fun main() {
    val xs: List<Pair<String, String>> = listOf("a" to "b", "c" to null).mapNotNull(::nonNullPair)
    println(xs)
}

Does anyone know a language where stuff like this works? What does the type system have to look like? I know the Kotlin team is thinking about this (https://github.com/Kotlin/KEEP/blob/master/proposals/kotlin-contracts.md#open-questions), but I'm curious if there's a precedent.

Typescript supports it when the method for filter used has a typeguard, which I think are sort of similar to contracts?