as in: ``` listOfObjects .filter { it.field !=...

# announcements

[Bernhard]

as in:

listOfObjects
    .filter { it.field != null }
    .map { it.field.method() }

[Tsvetozar Bonev]

Isn't using !! in this case null-safe technically?

[Bernhard]

yes

[Bernhard]

.map { it.field!!.method() }

[Bernhard]

filterNonNull only works if you keep the filtered value

[Bernhard]

an other example would be

[Bernhard]

listOfObjects
    .filter { it.field != null }
    .map { if (it.field.method()) it.nonNullField else it.otherNonNullField }

[Tsvetozar Bonev]

Maybe you could implement a wrapper of .filter() with a contract implying that returned values aren't null

[Tsvetozar Bonev]

don't know how that'd happen though, never used contracts

[Bernhard]

afaik you cant nest contracts

[Bernhard]

as in: you can create a contract based on an object

[Bernhard]

e.g. if returns true then input object was not null

[Bernhard]

but I don't think you can imply that a field on the input object is not null if the method returns true

[hudsonb]

There isn't a way to do this AFAIK

[Bernhard]

the only way that I found to circumvent this stuff is to pull all the needed values out into tuples

[Pavlo Liapota]

Maybe this?

listOfObjects
    .mapNotNull { it.field }
    .map { it.method() }

[hudsonb]

Doesnt solve his second example though

[hudsonb]

I try not to use !!, but this seems like a legit use of it

[Bernhard]

it's pretty much the only issue that I've encountered where I needed !!

[hudsonb]

My next suggestion was going to be Pair but sounds like youve done that. I prefer !! tbh

[Bernhard]

right, wrapping and unwrapping it is a bit less readable imho

[hudsonb]

Yeah

[hudsonb]

Definitely harder to reason about what the code is doing when its wrapping and unwrapping tuples to get at the data.

[Bernhard]

interesting thing is that this already works for simple logic:

data class Struct(val value: String?)

fun main(args: Array<String>) {
    val s = Struct("hi")
    if (s.value != null) 
        println(s.value.length)
}

[Bernhard]

I'll open a ticket

[Oleg Yukhnevich]

May be like this
listOfObjects.mapNotNull { it.field?.let { field -> if (field.method()) it.nonNullField else it.otherNonNullField } }

[Bernhard]

right, but that approach leads to code where you can't really make use of map and filter anymore

[Bernhard]

you can ofc also solve this issue by not using map/filter at all and go for a forloop and if

[Bernhard]

https://youtrack.jetbrains.com/issue/KT-29236

[Bernhard]

interstingly filterNotNull also doesn't use contracts btw https://github.com/JetBrains/kotlin/blob/d88fd8aa6f0865b59f84fd28a8b77487b7712da1/libraries/stdlib/common/src/generated/_Sequences.kt#L441

[Pavlo Liapota]

I think filterNotNull does not need a contract as it returns not nullable collection.

[Bernhard]

yes, as an unchecked cast

[gildor]

This is more efficient and shorter

.mapNotNull { it.field?.method() }