A modern programming language that makes developers happier.

kotlinlang

Is there any way to write this using a function reference (e.g. `::emit`)?
```suspend fun FlowCollector&lt;Something&gt;.emitNotNull(something: Something?) {
    something?.let { emit(it) }
}```


It doesn’t come up with any such recommendation. So perhaps not possible

does `?.let(FlowCollector::emit)` not work?

Ah, I think there are limits to method references and suspend functions

I suppose anyway should be using `also`  but then get similar:
```Type mismatch.
Required:
(TypeVariable(T)) → Unit
Found:
KSuspendFunction1&lt;Something, Unit&gt;```

This works:
```suspend fun FlowCollector&lt;Something&gt;.emitNotNull(something: Something?) {
    something?.suspendingAlso(::emit)
}

suspend inline fun &lt;T&gt; T.suspendingAlso(block: suspend (T) -&gt; Unit): T {
    block(this)
    return this
}```

Your `::emit` is `this::emit` . I am not sure this is what you want? ie. creating a bound reference on every call. In any case I think this is much more readable (but maybe your example is contrived):
```    suspend fun FlowCollector&lt;String&gt;.emitNotNull(something: String?) {
        if (something != null) emit(something)
    }```


Yes, I agree that’s much better. Just figuring out why some things don’t work :)

I think what threw me off at first was that `FlowCollector::emit` is actually a two parameter function. One for the receiver and one for the value to emit. This doesnt work nicely with let and method reference. The reason it works as a lambda is that receiver is passed implicitly.

I don’t think that’s the issue. `::emit` would work if emit was not suspending?
```fun FlowCollector&lt;Something&gt;.notSuspending(something: Something?) {
    
}

suspend fun FlowCollector&lt;Something&gt;.emitNotNull(something: Something?) {
    something?.also(::emit) // does not compile
    something?.also(::notSuspending) // does compile
}```

Right. There is the suspending part also. Mostly I am just talking about this because I see `this::emit` as a work-around to my issue (and not generally desirable).

Isn’t `this::emit` synonymous with `::emit` ?

Lets just stop here. Its just turning into me rambling