Master Combine Publishers in Swift

Builds custom Combine publishers for Swift's reactive programming framework, grounded in two core principles: publisher lifecycle (publishers are declarative and lazy, don't execute until subscribed, must handle .finished/.failure completion properly, use the right scheduler for UI vs. background work, and support cancellation for resource cleanup) and memory management (store cancellables in Set<AnyCancellable> or via .store(in:), avoid retain cycles with [weak self], cancel subscriptions in deinit when storing manually). It implements custom publishers from scratch - a Publisher/Subscription conforming type pair, such as a timer publisher that starts a repeating Timer on request(_:) and invalidates it on cancel() - and publisher extensions like exponential-backoff retry, which recursively retries a failed publisher with a delay that grows by a configurable multiplier each attempt before finally failing. Advanced patterns cover backpressure (a buffered publisher wrapping Combine's .buffer(size:prefetch:whenFull:) with drop-oldest, drop-newest, or error strategies) and priority-aware merging of two publishers (tagging values by priority and suppressing a low-priority value that arrives too soon after a high-priority one). Performance patterns cover lazy transformation (deferring a map operation via .handleEvents) and resource lifecycle management (a publisher that creates a resource, runs an operation against it, and guarantees cleanup on both completion and cancellation). Testing uses XCTest with XCTestExpectation and .store(in:) to assert the exact sequence of values a custom publisher emits.

Use it when Swift/Combine code needs a custom publisher beyond what the built-in operators provide - a timer source, retry-with-backoff, backpressure-aware buffering, priority merging, or guaranteed resource cleanup on cancellation - rather than composing only stock Combine operators.

Input is the reactive data source or transformation to model as a Combine publisher. Output is a custom Publisher/Subscription conformance, a publisher extension such as retry-with-backoff, a backpressure or merge strategy, or an XCTest suite verifying the publisher's emitted value sequence.

Built entirely on Apple's Combine framework (Publisher, Subscriber, Subscription, AnyCancellable, Publishers.Merge, DispatchQueue, Timer) and XCTest for verification, targeting Swift application code that already uses Combine for reactive state.

For Swift developers writing custom Combine publishers rather than just chaining built-in operators. Eight practices apply throughout: erase publisher types at API boundaries with eraseToAnyPublisher(), favor composition over inheritance, implement demand handling correctly in custom subscriptions, pick the right scheduler (.main for UI, .global() for computation), handle errors with .catch/.retry/.replaceError rather than crashing, avoid blocking operations inside a publisher chain, use .share() when multiple subscribers need one expensive upstream operation, and always implement cancellation for resource cleanup.

extension Publisher {
    func retryWithExponentialBackoff(
        retries: Int,
        initialDelay: TimeInterval = 1.0,
        multiplier: Double = 2.0
    ) -> AnyPublisher<Output, Failure> {
        self.catch { error -> AnyPublisher<Output, Failure> in
            if retries > 0 {
                let delay = initialDelay * pow(multiplier, Double(retries))
                return Just(())
                    .delay(for: .seconds(delay), scheduler: DispatchQueue.global())
                    .flatMap { _ in
                        self.retryWithExponentialBackoff(
                            retries: retries - 1,
                            initialDelay: initialDelay,
                            multiplier: multiplier
                        )
                    }
                    .eraseToAnyPublisher()
            } else {
                return Fail(error: error).eraseToAnyPublisher()
            }
        }
        .eraseToAnyPublisher()
    }
}