Simple problem with an API (from Vert.x), which uses coroutines

I have the following function declaration:

suspend fun <T> Context.executeBlockingAwait(blockingCodeHandler : Handler<Future<T>>) : T? {


public interface Handler<E> {

     * Something has happened, so handle it.
     * @param event  the event to handle
    void handle(E event);

I don’t get this compiled :frowning:

private suspend fun foo(ctx: Context) {
    ctx.executeBlockingAwait { fut ->

Type mismatch. Required: Handler<Future<String>> Found: (???) → [ERROR : ]

Also not with:

context.executeBlockingAwait<String> { future: Future<String> ->

Type mismatch. Required: Handler<Future<String>> Found: (Future<String>) → Unit

Isn’t this exactly how a handler should look like? Hmmm, I sadly don’t get it.


private suspend fun foo(ctx: Context) {
    ctx.executeBlockingAwait { fut ->

I thought that’s the return value from executeBlockingAwait(…)?

I’m getting

Type mismatch. Required: Handler<Future<???>> Found: (???) → String

But I thought I’m passing in the higher function, which is the Handler, and the handler has no return value (void). I forgot to mention that it’s a Java functional interface, but it might be obvious.

That said, the API would be super strange :wink:

I may have been too hasty. Future may not be what I expected.

Ist’s a Vert.x Future but just like a Promise/Future.

What happens if you try something along this line?

    private suspend fun foo(ctx: Context) {
        val s: String? = ctx.executeBlockingAwait(object : Handler<Future<String>> {
            override fun handle(event: Future<String>) {
                return event.complete("")

Strange thing, okay it works, but what is this?

val s: String? = ctx.executeBlockingAwait(Handler<Future<String>> { event -> event.complete("") })

IntelliJ says it should be converted to a lambda… is this Handler<Future<String>> something like a cast, because the type inference rules don’t work? Maybe because of Java?

I don’t have Vert.X so I just mimicked the interfaces you gave and wrote it up in Android Studio. I don’t have the same code you do, so had to make a few guesses.

From what I’ve gleaned both Handler, and Future can take type parameters of Any, so you need to help it along by being more specific. I’ll see if I can get something official to reference.

They just somehow generated these suspending extension methods, so I’m not sure. It’s in their 3.6.0-SNAPSHOT version and I’ve already posted on their mailing list a few days ago. I guess their intent was that one can use it with a simple lambda.

BTW: As I’m rather new to Kotlin, I currently don’t know what this explicit Handler<Future<String>> { ... } means. Is it meant as a shortcut for anonymous classes with an explicit type for the lambda?

Oh okay, they (the Vert.x guys) need to change this, I think It’s rather ugly… and thank you :slight_smile: