I've got a

suspend fun

which produces

ByteArray

in 16 byte chunks. Reading them is kinda time-intensive, so I was wondering if there's a concept of a lazy channel of bytes, so I say "ready me X bytes" without it reading everything.

https://square.github.io/okio/ ?

Doesn't look like it plays well with suspend?

You could also use `ktor-io`'s ByteReadChannel

Yeah it might be helpful to add some more context to what you're trying to do

I have:

suspend fun read4Pages(location: Byte): ByteArray = ...

I'm currently using:

suspend fun readAll(from: Byte, to: Byte) = {
val reads = (to - from + 1) / 4
    return (1..(reads)).flatMap {
        val pageNr = it * 4
        read4Pages(pageNr).toList()
    }.toByteArray()
}

... which is quite slow, because it reads everything. Takes about ~ 3s. However, there's information in the pages on how far I have to read (currently it's about 20% of the total size), so I want to avoid reading everything.

Maybe I am being obtuse here, but this hasn't clarified much for me to be able to provide any meaningful advice. I'm not sure what you're reading from and if that matters, nor where the 3s number is coming from. If you're needing to read from disk or network and it is a huge amount of data then sometimes there is no getting around it. It's unclear for read4Pages why it is returning a ByteArray which you then convert to a list, and then convert the group of lists back into a ByteArray.

I'm casting the collection types around, because the

flatMap

signature requires it.

Sounds like an unbuffered flow. The producer will only producer of the collector of ready to consume more.

Sounds about right, but I can't seem to find anything under that name in https://kotlinlang.org/api/kotlinx.coroutines/