Coroutines support. Non Blocking?

[Ulop]

What do you think about using/support Kotlin? Would it give us async operations?
I made a test project with AsyncRoute implementation. It's only scratch for testing.

class AsyncRoute(path: String, val handler: suspend RouteHandler.() -> Any) : RouteImpl(path) {
    override fun handle(request: Request, response: Response): Any = runBlocking {
        kotlin.run {
            handler(RouteHandler(request, response))
        }
    }
}

and use it like this

http.service.addRoute(HttpMethod.get, AsyncRoute("/nonblocking") {
        val jobs = (0..10).map {
            async(CommonPool) {
                longComputationAwait(it)
            }
        }
        val total =  jobs.sumBy { it.await() }
        total.toString()
    })

where longComputationAwait is

suspend fun longComputationAwait(x: Int): Int {
    println("Compute started in: ${System.currentTimeMillis()}")
    delay(1000)
    return x * x
}

and blocking analog of this route

http.get("/blocking") {
        val total = List(10){ longComputation(it) }.sum()
        total.toString()
    }

where longComputation is

fun longComputation(x: Int): Int {
            Thread.sleep(1000)
            return x * x
        }

as result "/blocking" page recived respons in 10 seconds as expected
"/nonblocking" page recived it in 1 second recived with same total value

Have this idea reason for live? Can we get more complex coroutine support?

[perwendel]

Async is a requested feature in the java project as well. We'll try to add it there and expose it in kotlin framework as well!

[mgenov]

Are there any plans for this feature?