Combine: publish elements of a sequence with some delay

Question

I'm new to Combine and I'd like to get a seemingly simple thing. Let's say I have a collection of integer, such as:

let myCollection = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

I'd like to publish each element with a delay of, for example, 0.5 seconds.

print 0
wait for 0.5secs
print 1
wait for 0.5secs
and so forth

I can easily get the sequence publisher and print the elements like this:

let publisherCanc = myCollection.publisher.sink { value in
    print(value)
}

But in this case all the values are printed immediately. How can I print the values with a delay? In Combine there's a .delay modififer, but it's not for what I need (indeed, .delay delays the entire stream and not the single elements). If I try:

let publisherCanc = myCollection.publisher.delay(for: .seconds(0.5), scheduler: RunLoop.main).sink { value in
    print(value)
}

All I get it's just an "initial" delay, then the elements are printed immediately.

Thanks for your help.

I'm not familiar with Combine, but here's a solution in RxSwift. https://stackoverflow.com/a/47585896/3141234 Just gotta find the corresponding method names in Combine, but the idea is simple. Make an observable that emites events at a set interval, zip that observable with your array's observable. — Alexander, Apr 14 '20 at 16:22
BTW I suggest gettting comfortable with RxSwift, perhaps even ReactiveCocoa. They're much more mature/popular frameworks, so they have much more documentation and existing code. Often times there's 1:1 mapping between their functions and Combine's, just with different names. — Alexander, Apr 14 '20 at 17:24

Dávid Pásztor · Accepted Answer · 2020-10-09T09:42:17.620

Using the idea from the answer linked by Alexander in comments, you can create a publisher that emits a value every 0.5 seconds using Timer.publish(every:on:in:), then zip that together with your Array.publisher to make your downstream publisher emit a value every time both of your publishers have emitted a new value.

Publishers.Zip takes the n-th element of its of its upstream publishers and only emits when both of its upstreams have reached n emitted values - hence by zipping together a publisher that only emits its values at 0.5 second intervals with your original publisher that emits all of its values immediately, you delay each value by 0.5 seconds.

let delayPublisher = Timer.publish(every: 0.5, on: .main, in: .default).autoconnect()
let delayedValuesPublisher = Publishers.Zip(myCollection.publisher, delayPublisher)
let subscription = delayedValuesPublisher.sink { print($0.0) }

score 13 · Answer 2 · answered Mar 21 '21 at 05:40

Try to use flatMap(maxPublishers:) with delay(for:scheduler:) operators.

import Foundation
import Combine

var tokens: Set<AnyCancellable> = []

let valuesToPublish = [1, 2, 3, 4, 5, 6, 7, 8, 9]
valuesToPublish.publisher
    .flatMap(maxPublishers: .max(1)) { Just($0).delay(for: 1, scheduler: RunLoop.main) }
    .sink { completion in
        print("--- completion \(completion) ---")
    } receiveValue: { value in
        print("--- value \(value) ---")
    }
    .store(in: &tokens)

Setting maxPublishers property you can specify the maximum number of concurrent publisher subscriptions. Apple

score 1 · Answer 3 · answered May 25 '21 at 14:24

Based on the examples provided in other answers, I came up with a solution with generics:

import Combine
import SwiftUI

struct TimedSequence<T: Any>  {
    typealias TimedJointPublisher = (Publishers.Zip<Publishers.Sequence<[T], Never>, Publishers.Autoconnect<Timer.TimerPublisher>>)
    
    var sink: AnyCancellable?

    init(array: [T], interval: TimeInterval, closure: @escaping (T) -> Void) {
        let delayPublisher = Timer.publish(every: interval, on: .main, in: .default).autoconnect()
        let timedJointPublisher = Publishers.Zip(array.publisher, delayPublisher)
        self.sink = timedJointPublisher.sink(receiveValue: {r in
            closure(r.0)
        })
    }
}

Usage:

1 - Basic types:

let m = TimedSequence(array: [1, 2, 3], interval: 2, closure: {
    element in
    let textReceived = String(element)        //assigns 1 ...2 seconds...then 2...2 seconds...then 3 to textReceived
})

let m = TimedSequence(array: ["Hello", "World"], interval: 2, closure: {
    element in
    let textReceived = element.upperCased()   //assigns HELLO ...2 seconds... then WORLD to textReceived

2 - Custom types:

class MyClass {
    var desc: String
    init(desc: String) {
        self.desc = desc
    }
}


let m = TimedSequence(array: [MyClass(desc: "t"), MyClass(desc: "s")], interval: 2, closure: {
    str in
    let textReceived = str.desc.uppercased()
})

Same as 1, except that str.desc (S and T respectively) gets assigned to textReceived at 2 second interval.

Combine: publish elements of a sequence with some delay

3 Answers3

Linked