A modern programming language that makes developers happier.

kotlinlang

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&lt;String?&gt;` while my position is that it should be `List&lt;String&gt;`. 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) -&gt; Boolean) -&gt; 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&lt;String&gt; = foo.asSequence().filterNotNull().filter { it.isNotEmpty() }.toList()
```

the best way right now might be to `.filterNotNull()` and then `.filter(String::isNotEmpty)`

making it a sequence if you’ve got a lot of elements

yeah, I came to the same conclusion as well

`    val bar = foo.filterNotNull().filterNot { it.isEmpty() }`

I am not too happy about this, but it does the correct thing

maybe we’ll eventually get something like `.filterNotNullAnd { ... }`

You can always suggest a feature like improved contracts for this on <http://kotl.in/issue|kotl.in/issue>

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

You can do it in one go with `mapNotNull`