Swift Academy · Lesson

Protocol Composition with &

Combining multiple protocols into a single type requirement.

Protocol Composition with & is a free Swift Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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?

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.

Frequently asked questions

Is the “Protocol Composition with &” lesson free?

Yes — the full text of “Protocol Composition with &” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

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; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

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