A modern programming language that makes developers happier.

kotlinlang

i have a suspend method that i want to make use of
```suspend fun lookupListings(): List&lt;QueryListings.SelectListingsResult&gt; {```
if i make use of runBlocking, i'm assuming it's physically blocking a thread until that suspend function completes, what is the better route to take here to get rid of the `runBlocking`s?
```class HomePage : PageResponse(
	title = "Page Title",
	description = "Page Description",
) {

	val listings = runBlocking {
		lookupListings()
	}

    val somethingElse = runBlocking {
        suspendLookupSomethingElse()
    }```
Edit: this is on the JVM

if you need it instantly it would have to be `runBlocking`. otherwise, you need some coroutine scope to execute the suspend function that isn't blocking. it depends how those values in `HomePage`  are being used

i'm building an html document using those listings
```			Box {
				Grid {
					listings.forEach { listing -&gt;
						ListingItem {
							+(listing.listingTitle ?: "")
						}
					}
				}
			}```


ok, so i guess that means i'll need to go suspend all the way to the main function otherwise runBlocking

are you generating static html to export or is this like a web server thing?

that's correct, i'm building a server-side rendered page which is including data from a DB

data from the DB is being pulled using Jasync which returns a future which i converted to a coroutine using Deferred

serving the HTML page is being done with VertX which is not using Coroutines, but is doing so in an async way as well, so i need to get this generated html to VertX without blocking

is this html being generated on the fly (per request) or statically all at once?

the whole document is generated all at once (home page -&gt; generate home page html, contact page -&gt; generate contact page html)

ah, sorry, i misunderstood, yes, it's on the fly per request

i'm not too sure how vertx ties in here but if i was thinking about ktor since requests are all suspend funs anyway i would make the whole chain suspend

in your case i'm really not sure what is best

i guess i'll just need to experiment, this is probably more complicated than it needs to be

VertX has a conversion kit to make it work just like Ktor: <https://vertx.io/docs/vertx-lang-kotlin-coroutines/kotlin/>

this should simplify things a bit if the webserver already supports Coroutines instead of trying to jump around between Coroutines, Futures and callbacks