public fun <T> async(c: suspend () -> T): Promise<T> {
    return Promise { resolve, reject ->
        c.startCoroutine(object : Continuation<T> {
            override fun resume(value: T) = resolve(value)

            override fun resumeWithException(exception: Throwable) = reject(exception)

            override val context = EmptyCoroutineContext
        })
    }
}

public suspend fun <T> Promise<T>.await() = suspendCoroutine<T> { c ->
    then({ c.resume(it) }, { c.resumeWithException(it) })
}

async {
    // do something
    val ajaxResponse = fetch(...).await()
    // do something
}

Promise

await()

break()

break()

suspend val

visit

suspend funs

suspend val Visitor.break get() = Helpers.break(this)

override suspend fun visitEnter(node: NodeTypeTwo){
  if(node.modelB.isSpecialCase()){
    break //treated as a property-get
  }
  //domain logic b, never called when the above if-clause is taken as per the `break` suspension
}

note of course that `suspend val`s do not yet exist, but im hoping their behaviour is fairly obvious

goto

suspendCoroutine

Continuation.resume

break

private suspend fun foo(): Int {
    null?.let {
        return bar() // Couldn't inline method call 'let'
    }
    return 23
}

private suspend fun bar(): Int {
    return 42
}