Kotlin Coroutines: Calling Deferred::await in Sequence::map

Question

why is it not possible to call Deferred::await in the Sequence::map function like it is possible in List::map?

I made a small example

fun example() = runBlocking {

    val list = listOf(1, 2, 3, 4)

    list.map { async { doSomething(it) } }
            .map { it.await() }

    list.asSequence()
            .map { async { doSomething(it) } }
            .map { it.await() }         // Error: Kotlin: Suspension functions can be called only within coroutine body

}

As you can see the last statement does not compile.

Answer 1

It's because list.map is an inline fun, which it can be because it's an eager operation that returns a new list. An inline fun can tolerate a suspend block because it's more like a macro: it gets expanded into the call site. As long as the call site is within a suspend block, this works fine.

sequence.map, on the other hand, is lazy and it just adds another lambda to the pipeline of operations that will be performed eventually, when you pull items from the sequence.

The closest match to a lazy sequence in the suspendable world is Flow, but it has a different model where you get all the data pushed to you in one go, whereas you can pull items from a lazy sequence one by one.

Answer 2

Adding to Marko's answer, which is correct:

Because the sequence is lazy, the await() call might happen after runBlocking is done, essentially. Neither the async call nor the await will happen until you start pulling elements off the list.

And in the case of the code above, nothing pulls the elements out of the sequence, so neither of the mapping operations on the sequence would happen inside the runBlocking block.