Introduction to Combine

Combine is Apple's framework for working with values that arrive over time . In this lesson you'll meet publishers, subscribers, @Published , sink , and AnyCancellable — and learn when Combine beats plain async/await.

Learn Introduction to Combine in our free Swift course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Swift course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• • What a Publisher and Subscriber are, and how data flows between them
• • Use @Published to turn a property into a stream of changes
• • Attach a subscriber with sink
• • Keep subscriptions alive with AnyCancellable and store(in:)
• • Read a publisher's Output and Failure types
• • Decide when to reach for Combine vs async/await

📊 Combine Building Blocks

Piece

Role

Example

Publisher

Emits values over time

Just(5)

Subscriber

Receives values

.sink { … }

@Published

Property to publisher

@Published var n = 0

AnyCancellable

Holds a subscription

.store(in: &bag)

1️⃣ Publishers and Subscribers

A publisher produces a stream of values; a subscriber consumes them. The simplest subscriber is sink , which runs a closure for each value. Many everyday types become publishers — even arrays.

2️⃣ @Published — Properties as Streams

Inside an ObservableObject , marking a property with @Published creates a publisher you reach with the $ prefix. Every change is broadcast to subscribers — this is exactly how SwiftUI views stay in sync.

Your turn. Fill in the two blanks to turn an array into a publisher and subscribe to it.

3️⃣ AnyCancellable — Keeping It Alive

A subscription stays active only as long as you hold its AnyCancellable . The common pattern is a Set<AnyCancellable> property plus .store(in:) , so every subscription lives as long as the owning object.

Now you try. Fill in the collection type and the storing operator.

Pro Tips

• 💡 Always store your cancellables. A forgotten subscription is silently cancelled the moment its token goes out of scope.
• 💡 Use Never as Failure when a stream can't error — it lets you use the simpler single-closure sink .
• 💡 Combine vs async/await: one-shot call → async/await; ongoing stream → Combine.
• 💡 Think in streams. Ask "what values flow over time?" before writing pipelines.

Common Errors (and the fix)

• Subscriber never fires — you didn't keep the AnyCancellable . Store it with .store(in:&bag) .
• "Cannot convert value of type 'Published<Int>.Publisher'" — subscribe to the $ projected value, e.g. object.$count , not the raw property.
• Compiler can't find Combine types — add import Combine at the top of the file.
• Error-handling closure required — your publisher's Failure isn't Never ; use the two-closure sink(receiveCompletion:receiveValue:) .

📋 Quick Reference

Task

Code

Meaning

One-value publisher

emit 5, finish

Array publisher

[1,2].publisher

emit each

Published property

stream of changes

Subscribe

.sink { v in … }

closure subscriber

Retain

keep alive

Frequently Asked Questions

Mini-Challenge: Score Tracker

Build a small ObservableObject and subscribe to its published property. Run it and check your output against the comments.

🎉 Lesson Complete!

• ✅ Publishers emit values over time; subscribers receive them
• ✅ @Published turns a property into a stream of changes
• ✅ sink attaches a closure-based subscriber
• ✅ Hold the AnyCancellable (often in a Set ) to keep it alive
• ✅ Use Combine for ongoing streams; async/await for one-shot work
• ✅ Next lesson: Combine Operators & Pipelines — transform streams with map, filter, debounce and more

Practice quiz

Continue this course

• Previous: Custom View Modifiers & ViewBuilder
• Next: Combine Operators & Pipelines