Protocol composition in practice in Swift - Step-by-Step Execution

Concept Flow - Protocol composition in practice

Define Protocol A

↓

Define Protocol B

↓

Create Struct/Class conforming to A & B

↓

Use protocol composition (A & B) as type

↓

Call methods from both protocols

↓

Observe combined behavior

This flow shows how two protocols are defined, combined, and used together in Swift to create flexible types.

Execution Sample

Swift

protocol A {
    func greet()
}
protocol B {
    func farewell()
}
struct Person: A, B {
    func greet() { print("Hello") }
    func farewell() { print("Goodbye") }
}
func welcome(_ entity: A & B) {
    entity.greet()
    entity.farewell()
}
let p = Person()
welcome(p)

This code defines two protocols, a struct conforming to both, and a function that accepts a parameter conforming to both protocols, then calls their methods.

Execution Table

Step	Action	Evaluation	Result
1	Define protocol A with greet()	protocol A created	Protocol A ready
2	Define protocol B with farewell()	protocol B created	Protocol B ready
3	Define struct Person conforming to A & B	Person struct created	Person has greet() and farewell()
4	Create instance p of Person	p = Person()	p is ready with both methods
5	Call welcome(p) with p as A & B	welcome(p) called	Inside welcome: entity.greet() and entity.farewell()
6	entity.greet() executes	print("Hello")	Output: Hello
7	entity.farewell() executes	print("Goodbye")	Output: Goodbye
8	Function welcome ends	return	Execution complete

💡 All steps executed; program ends after printing greetings.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
p	undefined	Person instance with greet and farewell	Passed as A & B to welcome	No change after function ends
entity	undefined	undefined	References p as A & B	No change after function ends

Key Moments - 3 Insights

Why can the function welcome accept a parameter typed as A & B?

Because the parameter uses protocol composition (A & B), it requires the argument to conform to both protocols, ensuring both greet() and farewell() methods are available, as shown in execution_table step 5.

What happens if Person only conformed to protocol A but not B?

The function welcome would not accept Person as argument because it requires both protocols. This would cause a compile-time error before step 5.

Why do we see both "Hello" and "Goodbye" printed?

Because welcome calls both entity.greet() and entity.farewell(), and Person implements both methods, as shown in execution_table steps 6 and 7.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, what method is called?

A welcome()

B farewell()

C greet()

D Person initializer

💡 Hint

Check the 'Action' and 'Evaluation' columns at step 6 in execution_table.

At which step does the instance 'p' get created?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for the step mentioning 'Create instance p of Person' in execution_table.

If Person did not conform to protocol B, what would happen at step 5?

A Compile-time error due to missing protocol conformance

B welcome(p) would run normally

C Only greet() would be called

D farewell() would print default message

💡 Hint

Refer to key_moments about protocol composition and conformance requirements.

Concept Snapshot

Protocol composition combines multiple protocols into one type.
Use syntax: func example(param: A & B) { }.
The parameter must conform to all protocols.
Allows flexible, reusable code.
Methods from all protocols are accessible.
Compile-time safety ensures conformance.

Full Transcript

This example shows how Swift protocols can be combined using protocol composition. Two protocols, A and B, are defined with methods greet() and farewell(). A struct Person conforms to both protocols by implementing these methods. A function welcome accepts a parameter typed as A & B, meaning it requires an object that conforms to both protocols. When welcome is called with a Person instance, it can safely call both greet() and farewell() methods. The execution table traces each step: defining protocols, creating the struct, instantiating Person, calling welcome, and printing outputs. The variable tracker shows how the instance 'p' and parameter 'entity' change during execution. Key moments clarify why protocol composition works and what happens if conformance is missing. The visual quiz tests understanding of method calls, instance creation, and conformance errors. The concept snapshot summarizes the syntax and benefits of protocol composition in Swift.

Practice

1. What does protocol composition in Swift allow you to do?

easy

A. Combine multiple protocols into one requirement without creating a new protocol

B. Create a new class that inherits from multiple classes

C. Define a protocol with stored properties

D. Override methods in a protocol extension

Solution

1. Step 1: Understand protocol composition concept

   Protocol composition uses the & operator to require multiple protocols at once without defining a new protocol.

2. Step 2: Compare options with concept

   Only Combine multiple protocols into one requirement without creating a new protocol correctly describes combining multiple protocols without creating a new one. Other options describe unrelated or incorrect Swift features.

3. Final Answer:

   Combine multiple protocols into one requirement without creating a new protocol -> Option A

4. Quick Check:

   Protocol composition = Combine protocols [OK]

Hint: Remember & means combine protocols, not inherit classes [OK]

Common Mistakes:

• Confusing protocol composition with class inheritance
• Thinking protocols can have stored properties
• Believing protocol extensions override methods

2. Which of the following is the correct syntax to declare a function parameter that requires both Codable and Equatable protocols using protocol composition?

easy

A. func save(item: Codable | Equatable) {}

B. func save(item: Codable & Equatable) {}

C. func save(item: Codable, Equatable) {}

D. func save(item: Codable && Equatable) {}

Solution

1. Step 1: Recall protocol composition syntax

   Swift uses & to combine protocols in type requirements, like Codable & Equatable.

2. Step 2: Evaluate each option

   func save(item: Codable & Equatable) {} uses correct & syntax. func save(item: Codable | Equatable) {} uses | which is invalid. func save(item: Codable, Equatable) {} uses comma which is invalid. func save(item: Codable && Equatable) {} uses && which is invalid.

3. Final Answer:

   func save(item: Codable & Equatable) {} -> Option B

4. Quick Check:

   Use & to combine protocols [OK]

Hint: Use & to combine protocols, not |, comma, or && [OK]

Common Mistakes:

• Using | or && instead of & for protocol composition
• Separating protocols with commas in parameter types
• Confusing logical operators with protocol composition

3. What will be the output of the following Swift code?

protocol A { func foo() }
protocol B { func bar() }
struct MyStruct: A, B {
  func foo() { print("foo") }
  func bar() { print("bar") }
}
func callBoth(item: A & B) {
  item.foo()
  item.bar()
}
let obj = MyStruct()
callBoth(item: obj)

medium

A. foo\nbar

B. foo

C. bar

D. Compilation error

Solution

1. Step 1: Understand protocol composition usage

   The function callBoth requires an argument conforming to both A and B. MyStruct conforms to both.

2. Step 2: Trace function calls

   Inside callBoth, foo() prints "foo" and bar() prints "bar". Both are called in order.

3. Final Answer:

   foo bar -> Option A

4. Quick Check:

   Both protocol methods called = foo\nbar [OK]

Hint: Both protocols' methods run in order when composed [OK]

Common Mistakes:

• Assuming only one protocol method runs
• Expecting a compile error due to protocol composition
• Confusing protocol conformance with inheritance

4. Identify the error in this Swift code using protocol composition:

protocol P1 { func p1Method() }
protocol P2 { func p2Method() }
func testFunc(param: P1 & P2) {
  param.p1Method()
  param.p2Method()
}
struct S: P1 {
  func p1Method() { print("P1") }
}
let s = S()
testFunc(param: s)

medium

A. Method p2Method is missing in testFunc

B. Function testFunc has wrong parameter syntax

C. Protocols P1 and P2 cannot be combined

D. Struct S does not conform to protocol P2

Solution

1. Step 1: Check struct conformance

   Struct S conforms only to P1, missing P2 conformance.

2. Step 2: Analyze function parameter requirement

   Function testFunc requires a parameter conforming to both P1 and P2. Passing s fails because s lacks P2.

3. Final Answer:

   Struct S does not conform to protocol P2 -> Option D

4. Quick Check:

   Missing protocol conformance causes error [OK]

Hint: Check all protocols are conformed before passing composed type [OK]

Common Mistakes:

• Assuming partial protocol conformance is enough
• Thinking function parameter syntax is incorrect
• Believing protocols cannot be combined with &

5. Given these protocols and structs:

protocol Drawable { func draw() }
protocol Colorable { var color: String { get } }
struct Circle: Drawable, Colorable {
  var color: String
  func draw() { print("Drawing a circle") }
}
struct Square: Drawable {
  func draw() { print("Drawing a square") }
}

Which of the following function signatures correctly accepts only objects that are both Drawable and Colorable?

hard

A. func render(item: Drawable) { item.draw() }

B. func render(item: Drawable | Colorable) { item.draw() }

C. func render(item: Drawable & Colorable) { item.draw(); print(item.color) }

D. func render(item: Colorable) { print(item.color) }

Solution

1. Step 1: Understand protocol composition for parameters

   To accept only objects conforming to both Drawable and Colorable, use Drawable & Colorable.

2. Step 2: Check each function signature

   func render(item: Drawable & Colorable) { item.draw(); print(item.color) } uses correct composition and accesses both draw() and color. Options A, B, and D either use invalid syntax or accept only one protocol.

3. Final Answer:

   func render(item: Drawable & Colorable) { item.draw(); print(item.color) } -> Option C

4. Quick Check:

   Use & to require multiple protocols [OK]

Hint: Use & to require multiple protocols in parameters [OK]

Common Mistakes:

• Using | instead of & for protocol composition
• Accepting only one protocol when both are needed
• Trying to access properties/methods not guaranteed by parameter type