Chapters
Chapters

Chapters

Hide chapters

Combine: Asynchronous Programming With Swift

Fourth Edition · iOS 16 · Swift 5.8 · Xcode 14

Before You Begin

Section 0: 5 chapters
Show chapters Hide chapters

Section I: Introduction to Combine

Section 1: 2 chapters
Show chapters Hide chapters

Section II: Operators

Section 2: 6 chapters
Show chapters Hide chapters

Section III: Combine in Action

Section 3: 6 chapters
Show chapters Hide chapters

Section IV: Advanced Combine

Section 4: 5 chapters
Show chapters Hide chapters

Section V: Building a Complete App

Section 5: 2 chapters
Show chapters Hide chapters

18. Custom Publishers & Handling Backpressure
Written by Florent Pillet

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

At this point in your journey to learn Combine, you may feel like there are plenty of operators missing from the framework. This may be particularly true if you have experience with other reactive frameworks, which typically provide a rich ecosystem of operators, both built-in and third-party. Combine allows you to create your own publishers. The process can be mind-boggling at first, but rest assured, it’s entirely within your reach! This chapter will show you how.

A second, related topic you’ll learn about in this chapter is backpressure management. This will require some explanation: What is this backpressure thing? Is that some kind of back pain induced by too much leaning over your chair, scrutinizing Combine code? You’ll learn what backpressure is and how you can create publishers that handle it.

Creating Your Own Publishers

The complexity of implementing your own publishers varies from “easy” to “pretty involved.” For each operator you implement, you’ll reach for the simplest form of implementation to fulfill your goal. In this chapter, you’ll look at three different ways of crafting your own publishers:

  • Using a simple extension method in the Publisher namespace.
  • Implementing a type in the Publishers namespace with a Subscription that produces values.
  • Same as above, but with a subscription that transforms values from an upstream publisher.

Note: It’s technically possible to create a custom publisher without a custom subscription. If you do this, you lose the ability to cope with subscriber demands, which makes your publisher illegal in the Combine ecosystem. Early cancellation can also become an issue. This is not a recommended approach, and this chapter will teach you how to write your publishers the right way.

Publishers as Extension Methods

Your first task is to implement a simple operator just by reusing existing operators. This is as simple as you can get.

Testing your Custom Operator

Now you can test your new operator. Add this code below the extension:

The Subscription Mechanism

Subscriptions are the unsung heroes of Combine: While you see publishers everywhere, they are mostly inanimate entities. When you subscribe to a publisher, it instantiates a subscription which is responsible for receiving demands from the subscribers and producing the events (for example, values and completion).

Kuzqwxoxig cazouguf milmcwoyzaom fuqeokhg naduuw midooxaj wapai etgf gayasj kutwjtukaw 5 6 1 5 3 6 iflidiy voqety inukb wujau dwahrq sukd lopiozil fodugs Remndroctiiv 7 Yexsilxat mbaegar qomlpvuvmios suftd omow cutjgfaqzeoh

Publishers Emitting Values

In Chapter 11, “Timers,” you learned about Timer.publish() but found that using Dispatch Queues for timers was somewhat uneasy. Why not develop your own timer based on Dispatch’s DispatchSourceTimer?

Adding the DispatchTimer Publisher

You can now start creating your DispatchTimer publisher. It’s going to be straightforward because all the work occurs inside the subscription!

Building Your Subscription

The subscription’s role is to:

Adding Required Properties to Your Subscription

Now add these properties to the subscription class’ definition:

Initializing and Canceling Your Subscription

Now, add an initializer to your DispatchTimerSubscription definition:

Letting Your Subscription Request Values

Do you remember what you learned in Chapter 2, “Publishers & Subscribers?” Once a subscriber obtains a subscription by subscribing to a publisher, it must request values from the subscription.

Configuring Your Timer

Add this code to the body of this last if conditional:

Activating Your Timer

Now that you’ve configured your source timer, store a reference to it and activate it by adding this code after setEventHandler:

Testing Your Timer

You’re now ready to test your new timer!

Publishers Transforming Values

You’ve made serious progress in building your Combine skills! You can now develop your own operators, even fairly complex ones. The next thing to learn is how to create subscriptions which transform values from an upstream publisher. This is key to getting complete control of the publisher-subscription duo.

Implementing a ShareReplay Operator

To implement shareReplay() you’ll need:

Initializing Your Subscription

Next, add the initializer to the subscription definition:

Sending Completion Events and Outstanding Values to the Subscriber

You’ll need a method which relays completion events to the subscriber. Add the following to the subscription class to satisfy that need:

Canceling Your Subscription

Canceling the subscription is even easier. Add this code:

Wrapping Up Your Subscription

Now, add the following method to accept completion events and your subscription class will be complete:

Coding Your Publisher

Publishers are usually value types (struct) in the Publishers namespace. Sometimes it makes sense to implement a publisher as a class like Publishers.Multicast, which multicast() returns, or Publishers.Share which share() returns. For this publisher, you’ll need a class, similarly to share(). This is the exception to the rule, though, as most often you’ll use a struct.

Adding the Publisher’s Required Properties

Now, add the properties your publisher will need to the definition of ShareReplay:

Initializing and Relaying Values to Your Publisher

Firstly, add the necessary initializer to your ShareReplay publisher:

Letting Your Publisher Know When It’s Done

Secondly, add this method to handle completion events:

Creating Your Subscription

Next, add this code to the method to create the subscription and hand it over to the subscriber:

Subscribing to the Upstream Publisher and Handling Its Inputs

You are now ready to subscribe to the upstream publisher. You only need to do it once: When you receive your first subscriber.

Adding a Convenience Operator

Your publisher is complete! Of course, you’ll want one more thing: A convenience operator to help chain this new publisher with other publishers. Add it as an extension to the Publishers namespace at the end of your playground:

Testing Your Subscription

Add this code to the end of your playground to test your new operator:

Verifying Your Subscription

Fantastic! This works exactly as you wanted. Or does it? How can you verify that the publisher is being subscribed to only once? By using the print(_:) operator, of course! You can try it by inserting it before shareReplay.

Handling Backpressure

In fluid dynamics, backpressure is a resistance or force opposing the desired flow of fluid through pipes. In Combine, it’s the resistance opposing the desired flow of values coming from a publisher. But what is this resistance? Often, it’s the time a subscriber needs to process a value a publisher emits. Some examples are:

Using a Pausable Sink to Handle Backpressure

To get started, switch to the PausableSink page of the playground.

Testing Your New Sink

You can now try your new sink! To make things simple, simulate cases where the publisher should stop sending values. Add this code:

Key Points

Wow, this was a long and complex chapter! You learned a lot about publishers:

Where to Go From Here?

You learned about the inner workings of publishers, and how to set up the machinery to write your own. Of course, any code you write — and publishers in particular! — should be thoroughly tested. Move on to the next chapter to learn all about testing Combine code!

17. Schedulers
19. Testing
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now