if you tell me which API is necessary to wrap, I could take a look for the next version

I believe the one both me and @kingsley were thinking of is

Channel

, where

val x = produce { send(3), send(4), send(5) }

val mapped = x.map { it * 2 }

would provide a channel containing

6

,

8

and

10

, while preserving the suspend (and close) semantics meaning, I believe, its safely implemented with

inline fun <T, R> Channel<T>.map(
    crossinline transform: (T) -> R
): Channel<R> = produce { 
  for(message in this){
    val next = recieve()
    //try-catch might be a big problem here.
    send(transform(next))
  }
  send(transform(recieve())) 
}

you mean this? http://arrow-kt.io/docs/patterns/monad_comprehensions/

also, regarding exceptions, Our illustrious coroutine commander-in-cheif has outsmarted me. This is from the docs of

produce

Uncaught exceptions in this coroutine close the channel with this exception as a cause and the resulting channel becomes failed, so that any attempt to receive from such a channel throws exception.

@groostav you mean this one https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental.channels/map.html