How would I implement a sequence doing HTTP request using the Ktor client? I get an error about restricted suspending functions when using

sequence { }

sequence doesn’t support any kind async events, this is syncronous only abstraction

Oh, ok

In future you also can use cold streams, when they will be released, for now Channels is the only abstraction for data streams compatible with coroutines

I’m basically implementing pagination, I don’t know much about channels. Is there an example somewhere on how to use channels for that?

I would start first from reading official docs https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/channels.md

Yeah that’s what I get from those docs. So

send

would not be called until there’s a consumer, right?

Depends on channel type

Sorry to highjack the thread, but you mentioned cold streams. Would they work similar to Rx observables?

@Fredrik Larsen Yes, the main idea is the same, but based on coroutines More details: https://github.com/Kotlin/kotlinx.coroutines/issues/254

Interesting. Thank you @gildor

@gildor when using a producer, it does one more request than needed because it waits for a

receive

when I call

send

, but when I call

send

I already did the next request. Is there a way to start the next request when

receive

is called, and not before, to prevent downloading potentially useless data?

I'm not entirely sure if

onSend

would get you that. @gildor do you happen to know if

onSend

is only a listener event or if it actually puts an item on the queue as well?

@bdawg.io this does download the next page before it’s needed. Also `onSend`’s prototype is scary

@ribesg I'm not understanding why. Unless you're specifying a capacity on your producer, it should suspend until someone `receive`s it. That's why it's called a Rendezvous channel

You’re calling loadPageNum before blocking on send

That sounds like a cold stream. An alternative is to return a

Lazy<ReceiveChannel<YourType>>

and then have your consumer unwrap the value before consuming

val pages by lazy { loadPages() }
pages.consumeEach { ... }

That doesn’t change anything as we’re still loading one more page than needed.

Why doesn't it change anything? Only one page is loaded at a time and it doesn't get loaded until first access of the

Lazy

(for above, not until

pages.consumeEach

is called)?

@bdawg.io I’m not sure how to explain it better, but you always retrieve a page before calling

send

which is the blocking point. So you always have a unused page in memory, which may never be used. Your

lazy

trick only works on the first page.

@ribesg Yes, exactly, this is how hot streams (channels) work and this will be properly solved only by cold streams

In the meantime, here’s my solution:

interface PageIterator<T> {
        suspend fun next(): List<T>
    }

object : PageIterator<MyType> {

            private var lastReturnedPage = -1
            private var done = false

            override suspend fun next(): List<MyType> {
                if (done) return emptyList()
                val res = doMyHttpRequest(++lastReturnedPage)
                done = lastReturnedPage == res.nbPages - 1
                return res.results
            }

        }

Sure, this is your own solution for this

Yes, I know that cold streams are the solution, but I needed an actual real solution for now, not a future one 🙂

It’s not so a future, planned for April, as I heard But I agree, nothing wrong with own case-specific solution, especially if you don’t integrate with other data streams

A lot of things I need will be out very soon, that’s unfortunate but I need to progress in my implementation

Again, I think it’s completely fine, some kind high level abstraction for streams required only if you have to manage multiple data streams and it may be much more tricky with ad-hoc solution

Yeah, in my case I just needed a

suspend

next

function doing an Http request, so I did just that. Hopefully I’ll be able to use existing things in the future.