Map an iterable asynchronously using limited concurrency.

Async.kt

/**
 * A very simple, non-blocking semaphore.
 */
class Semaphore(capacity: Int) {
    private val channel = Channel<Boolean>(capacity)

    suspend fun acquire() {
        channel.send(true)
    }

    suspend fun release() {
        channel.receive()
    }
}

/**
 * Maps the iterable asynchronously using at most the given given concurrency.
 */
suspend fun <T, R> Iterable<T>.mapAsync(concurrency: Int, transform: suspend (T) -> R): List<R> = coroutineScope {
    val semaphore = Semaphore(concurrency)

    map {
            semaphore.acquire()
            async { transform(it).also { semaphore.release() } }
        }
        .map { it.await() }
}