A modern programming language that makes developers happier.

kotlinlang

Hello,
I have a questions regarding transformation of list:
```val result = myList
            .filter { it.nullableProperty != null }
            .map { it.nullableProperty!!.fromAccount }```
Why do I have to use the non-null asserted call in the map step?

This is because `filter` is generic and has the same type of element as output. The condition in the filter  leads to a smart cast within the filter lambda, but that smart-cast type doesn't make it out.

This is why the stdlib introduced `filterNotNull` for exactly this purpose

because `filter` does not change generic arguments type as shown by its signature:
```public inline fun &lt;T&gt; Iterable&lt;T&gt;.filter(predicate: (T) -&gt; Boolean): List&lt;T&gt;```
Looking at your code you can achieve what you need  explicitly calling `map` and then `filterNotNull`:

```val result = myList
            .map { it.nullableProperty }
            .filterNotNull()
            .map { it.fromAccount }```
But in your use case `mapNotNull` with safe access to `fromAccount` would fit perfectly achieving exactly the same:
```val result = myList.mapNotNull { it.nullableProperty?.fromAccount }```

(those two would have same result only if `fromAccount` is non-nullable; otherwise first one could return null, and second wouldn't)

<@U01FA7E9T4N> whoops, you're absolutely right, probably didn't have to rush so much with the comment :)