How to have a publisher continue even after timeout? – Ios swift

My understanding is:

• If apiCall4 publishes its first output before the timeout, you only want the genuine outputs from apiCall4.

• If apiCall4 doesn’t publish its first output before the timeout, you want to publish a default value, but you want to allow apiCall4 to continue running, and use its output if it eventually publishes anything.

Here’s one way to solve this.

• We’ll use a Just with a delay to publish the default output after the timeout.

• We’ll use map to tag the default output and the genuine outputs, so we can distinguish them downstream.

• We’ll use merge to combine the tagged outputs of apiCall4 and the delayed Just into a single stream.

• We’ll then use scan to keep some state about whether we’ve ever seen a genuine output, so if we get the default output after seeing a genuine output, we can discard the default output.

• Since scan publishes its entire state, and always publishes when its upstream publishes, we can’t actually discard the default output in scan, nor can we publish just the output without the extra state. So we’ll use compactMap after scan to strip off scans extra state and actually discard if we get the default output after a genuine output.

Here’s the type we’ll use to tag each output with its genuine-ness:

fileprivate struct Wrapper<Output> {
    var output: Output
    var isGenuine: Bool
}

And here’s the type we’ll use to hold the extra scan state:

fileprivate struct ScanState<Output> {
    var output: Output?
    var hasSeenGenuine: Bool = false
}

And here’s how we assemble the pieces, as described above:

extension Publisher {
    func defaulting<S: Scheduler>(
        to defaultOutput: Output,
        after timeout: S.SchedulerTimeType.Stride,
        scheduler: S
    ) -> some Publisher<Output, Failure> {
        let genuine = self
            .map { Wrapper(output: $0, isGenuine: true) }

        let defaulted = Just(Wrapper(
            output: defaultOutput,
            isGenuine: false
        ))
            .setFailureType(to: Failure.self)
            .delay(for: timeout, scheduler: scheduler)

        return genuine.merge(with: defaulted)
            .scan(ScanState<Output>()) { state, wrapper in
                if state.hasSeenGenuine && !wrapper.isGenuine {
                    return ScanState(output: nil, hasSeenGenuine: true)
                } else {
                    return ScanState(
                        output: wrapper.output,
                        hasSeenGenuine: wrapper.isGenuine || state.hasSeenGenuine
                    )
                }
            }
            .compactMap { $0.output }
    }
}

Here’s a test function:

func runTest(call4Delay: DispatchQueue.SchedulerTimeType.Stride) -> AnyCancellable {
    let apiCall1 = Just("answer1").delay(for: .milliseconds(300), scheduler: DispatchQueue.main)
    let apiCall2 = Just("answer2").delay(for: .milliseconds(400), scheduler: DispatchQueue.main)
    let apiCall3 = Just("answer3").delay(for: .milliseconds(500), scheduler: DispatchQueue.main)
    let apiCall4 = Just("answer4").delay(for: call4Delay, scheduler: DispatchQueue.main)

    let defaultedCall4 = apiCall4.defaulting(to: "default", after: .milliseconds(1000), scheduler: DispatchQueue.main)

    let combo = apiCall1.combineLatest(apiCall2, apiCall3, defaultedCall4)
    let ticket = combo.sink { print($0) }
    return ticket
}

The timeout is one second. If I run a test with apiCall4 publishing after 900 milliseconds, I only see the genuine output:

("answer1", "answer2", "answer3", "answer4")

If I run a test with apiCall4 publishing after 1100 milliseconds, I see the default output followed by the genuine output:

("answer1", "answer2", "answer3", "default")
("answer1", "answer2", "answer3", "answer4")