So I have a piece of code that looks like this:

val foo = listOf("foo", "bar", null, "")
    val bar = foo.filter { !it.isNullOrEmpty() }

the compiler is arguing that

bar

is

List<String?>

while my position is that it should be

List<String>

. Am I expecting too much from contracts? And is there a better way to write this?

it might also have something to do with the fact that filter is defined as

((T) -> Boolean) -> T

, which makes transforms to the non-null version of

T

kind of a higher effort thing

Here's the fixed version:

val foo = listOf("foo", "bar", null, "")
val bar: List<String> = foo.asSequence().filterNotNull().filter { it.isNotEmpty() }.toList()

the best way right now might be to

.filterNotNull()

and then

.filter(String::isNotEmpty)

yeah, I came to the same conclusion as well

I mean agreed but ¯\_(ツ)_/¯

You can always suggest a feature like improved contracts for this on kotl.in/issue

I should probably do that

It's under open questions: https://github.com/Kotlin/KEEP/blob/master/proposals/kotlin-contracts.md#open-questions

awesome. thanks

You can do it in one go with

mapNotNull