Swift Academy · Lesson

Protocol Composition with &

Combining multiple protocols into a single type requirement.

Lesson 1 of 412 steps

Protocol Composition with & is a free Swift Academy lesson on CoddyKit. This is lesson 1 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

Welcome

Protocol composition lets you combine multiple protocols into a single type requirement using `&`. This is Swift's answer to multiple inheritance.

Basic Composition

```swift protocol Named { var name: String { get } } protocol Aged { var age: Int { get } } func describe(_ entity: Named & Aged) { print("\(entity.name) is \(entity.age)") } ``` `Named & Aged` is a temporary type requirement, not a new protocol.

Using in Function Parameters

```swift protocol Drawable { func draw() } protocol Animatable { func animate() } func render(_ view: Drawable & Animatable) { view.draw() view.animate() } ```

Storing Composed Types

```swift var entity: Named & Aged = makePerson() entity.name // accessible entity.age // accessible ``` The variable type constrains which protocols' members are accessible.

Composition with Classes

```swift protocol Configurable { func configure() } func setup(_ vc: T) { vc.configure() present(vc, animated: true) } ``` Compose a class requirement with a protocol using `&` in generics.

Protocol Composition vs New Protocol

```swift // Don't create a new protocol just to combine: protocol NamedAndAged: Named, Aged {} // often unnecessary // Prefer inline composition at use sites: func describe(_ e: Named & Aged) { } ``` New protocols only make sense when the combination needs extension methods.

typealias for Long Compositions

```swift typealias Service = Authenticable & Cacheable & Loggable func process(service: Service) { service.authenticate() service.log("processing") } ``` Use `typealias` to name commonly used compositions.

Composition in Generic Constraints

```swift func fetchAndCache(_ resource: T) async throws { let data = try await resource.fetch() resource.cache(data) } ```

Protocol Inheritance vs Composition

• Inheritance: `protocol C: A, B {}` — C inherits all requirements of A and B • Composition: `A & B` — inline, no new type Use inheritance when all conforming types must satisfy both; composition at call sites.

Real-World Example: Delegate + DataSource

```swift func setup(_ vc: UITableViewDelegate & UITableViewDataSource) { tableView.delegate = vc tableView.dataSource = vc } ``` A single view controller often satisfies both — composition lets you express this concisely.

Quick Check

Which operator combines multiple protocols into a single type requirement?

Answer it in the interactive lesson

Recap

Key takeaways: • `Protocol1 & Protocol2` — inline composition • Use in parameters, return types, and generic constraints • `typealias` names frequently used compositions • Prefer composition over creating new empty-body protocols • Can mix class requirements: `UIViewController & MyProtocol` Next: conditional conformance.

Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 122
Lessons: 409

Start learning free View the full course

Frequently Asked Questions

Is the “Protocol Composition with &” lesson free?

Yes — any 3 lessons of the Swift Academy learning path, including “Protocol Composition with &”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

What will I learn in “Protocol Composition with &”?

Combining multiple protocols into a single type requirement. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 1 of 4.

How long does the “Protocol Composition with &” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Swift Academy