or suspending lambdas i guess

# coroutines

[kevinherron]

or suspending lambdas i guess

[jw]

val foo = suspend { delay(100); println("Hi") }
runBlocking {
  foo()
}

[jw]

https://pl.kotl.in/3s10viQ8Q

[kevinherron]

can it take a parameter somehow?

[Big Chungus]

You can use suspend lamda like any other lamda

[kevinherron]

I should better qualify this, hang on

[kevinherron]

given:

suspend fun <T, K, R> groupMapCollateSuspending(
    items: List<T>,
    grouper: (T) -> K,
    mappers: (K) -> suspend (List<T>) -> List<R>
): List<R> {

    val pending = items.map { Pending<T, R>(it) }

    val grouped: Map<K, List<Pending<T, R>>> =
        pending.groupBy { grouper(it.item) }

    val jobs = mutableListOf<Job>()

    grouped.forEach { (key, pendingForKey) ->
        coroutineScope {
            jobs += this.launch {
                val itemsForKey = pendingForKey.map { it.item }
                val results = mappers(key)(itemsForKey)

                for (i in 0 until pendingForKey.size) {
                    pendingForKey[i].result = results[i]
                }
            }
        }
    }

    jobs.forEach { it.join() }

    return pending.map { it.result!! }
}

private class Pending<T, R>(internal val item: T) {
    @Volatile
    internal var result: R? = null
}

[Big Chungus]

Val x = suspend String.(Int, Any) -> Long

[kevinherron]

I cannot call it like this:

groupMapCollateSuspending(
    readValueIds,
    { id -> id.key() },
    { key ->
        { ids: List<ReadValueId> ->
            when (key) {
                DeviceValueRead -> readDeviceValues(ids)
                DeviceNonValueRead -> readDeviceNonValues(ids)
                LocalAttributeRead -> readLocalAttributes(ids)
            }
        }
    }
)

[Big Chungus]

That's valid

[kevinherron]

the IDE does not complain, but the compiler does

[serebit]

Try enabling new type inference

[kevinherron]

yeah, new type inference makes it work

[kevinherron]

ok, good enough for me