WatchService

someBlockingMethod()

CommonPool

run(CommonPool) { someBlockingMethod() }

CommonPool

makeRequest

a suspend

val jobs = (1..1000).map { n ->
    defer(CommonPool) {
        try {
            makeRequest(n)
        }catch (e : Exception) {
            Pair(n,e.message)
        }
    }
}

runBlocking {
    jobs.forEach {
        val r = it.await()
        println("Got response for ${r.first} - ${r.second}")
    }

}

suspend fun makeRequest(i : Int): Pair<Int, Int> {
   println("Creating request $i")
    val con = URL("<https://slack.com/>").openConnection() as HttpsURLConnection
    con.connectTimeout = 1000
    con.readTimeout = 1000
    con.instanceFollowRedirects = true
    con.requestMethod = "GET"
   // sleep(1000)
    return Pair(i, con.responseCode)
}

markRequest

suspend

suspend

makeRequest

CommonPool

it.await()

it.await()

runBlocking

runBlocking {
    launch(context) { // launch another coroutine in the context of this thread 
       while (true) {
            println(”I’m not blocked!”)
            delay(100)
       }
    }
    jobs.forEach {
        val r = it.await()
        println("Got response for ${r.first} - ${r.second}")
    }
}

'kotlinx.coroutines.experimental.NonCancellable' is compiled by a pre-release version of Kotlin and cannot be loaded by this version of the compiler

import kotlinx.coroutines.experimental.*

import kotlin.coroutines.experimental.*

suspend fun f() = suspendCoroutine<Unit> {
	cont ->
    println("YEAH")
    cont.resume(Unit);
}

class someController(fileSystem: FancyAsyncFileSystem) {
  override fun initialize() = suspending {
    //things that call other suspend funs and async methods
  }

  @FXML fun handleWhateverAction(userAction: Event) = suspending {

    val fileContent = await(fileSystem.loadFileAsync(Paths.get(textField.text)))
    //things that call other suspend...

    filePreviewArea.text = fileContent
  }
}

class WhateverControllerTests {
  @Test fun `when clicking on the whatever whatever should whatever the whatevers`(){
    //setup
    val fs = FakeFancyFileSystem().apply { setContent("a/b/c", "testing!") }
    val controller = WhateverController(fs).apply {
      textField.text = "a/b/c"
    } 

    //act
    controller.handleWhateverAction(NonDescriptEvent)

    //problem: async computation started and because of the enforced `void`-ness of the java handlers, any reference to a Future object or something I can synchronize with is gone
    //assert
     assertThat(controller.filePreviewTextArea.text).isEqualTo("testing!")
  }
}