It's easy to get lost in the

<?>

stuff 😒imple_smile:

I'm thinking that maybe I might create a wrapper to the producer

What you're doing looks fine to me, I'll give it a shot myself.

Neither of them are mine, I wan't to make call-site filtering for convenience

Hmm just removing

in

works for me:

fun <T: Any> Producer<T?>.consume(consume: (T) -> Unit) {
	attachConsumer { it?.let(consume) }
}

Oh omg

Sidenote: I'd name the function something different,

attachConsumerDropNulls

or something. It's easy to forget values are silently being dropped here when using this.

Yes, I agree, the real name is

observeNonNulls()

Allright, just making sure.

Looking at it, if we claim that our producer is of

T?

, wouldn't it make setting our upper bound of

T

to

Any

redundant?

Nope, it doesn't do that.

The linter doesn't say anything, but It works just the same way.

Well in this particular case it indeed doesn't matter, but it's not the same. Try for example

prod.consume<String?> {  }

.

Oh yes, indeed. Let me see if I got it then: making

<T> ... <T?>

will tell the compiler that my consumer can both consume nullable types or not, whereas my producer will always produce nullable.

Yes! In this particular case though, a function type in Kotlin has declaration site variance on the parameter type so a parameter that accepts nullable arguments or indeed

Any?

would be fine too. That why it doesn't matter in this case.

package kotlin.jvm.functions

public interface Function1<in P1, out R> : kotlin.Function<R> {
    public abstract operator fun invoke(p1: P1): R
}

Great. That was very helpful, thanks!

You're welcome!