Protocol composition in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a protocol named Drivable.

Swift

protocol [1] {
    func drive()
}

Drag options to blanks, or click blank then click option'

ADriving

BDriveable

CDrivable

DDriver

Attempts:

3 left

💡 Hint

Common Mistakes

Using a noun instead of an adjective for the protocol name.

Misspelling the protocol name.

The protocol is named Drivable to represent something that can be driven.

2fill in blank

medium

Complete the code to declare a protocol named Flyable with a fly() method.

Swift

protocol [1] {
    func fly()
}

Drag options to blanks, or click blank then click option'

AFlyable

BFlier

CFlying

DFly

Attempts:

3 left

💡 Hint

Common Mistakes

Using a noun instead of an adjective for the protocol name.

Forgetting to include the method signature.

The protocol is named Flyable to indicate the ability to fly.

3fill in blank

hard

Fix the error in the protocol composition syntax to combine Drivable and Flyable.

Swift

func operate(vehicle: [1]) {
    vehicle.drive()
    vehicle.fly()
}

Drag options to blanks, or click blank then click option'

ADrivable | Flyable

BDrivable & Flyable

CDrivable, Flyable

DDrivable + Flyable

Attempts:

3 left

💡 Hint

Common Mistakes

Using commas instead of '&' to combine protocols.

Using '|' or '+' which are invalid operators here.

In Swift, protocol composition uses the ampersand (&) to combine protocols.

4fill in blank

hard

Fill both blanks to declare a variable vehicle that conforms to both Drivable and Flyable protocols.

Swift

var vehicle: [1] = [2]()

Drag options to blanks, or click blank then click option'

ADrivable & Flyable

BCarPlane

CDrivable

DFlyable

Attempts:

3 left

💡 Hint

Common Mistakes

Using only one protocol in the type annotation.

Using a class name that does not conform to both protocols.

The variable type uses protocol composition with '&', and the instance is of a class named CarPlane that conforms to both protocols.

5fill in blank

hard

Fill all three blanks to define a function testVehicle that accepts a parameter conforming to Drivable and Flyable, then calls both methods.

Swift

func testVehicle(vehicle: [1]) {
    vehicle.[2]()
    vehicle.[3]()
}

Drag options to blanks, or click blank then click option'

ADrivable & Flyable

Bdrive

Cfly

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names like 'run'.

Not combining protocols correctly in the parameter type.

The parameter type uses protocol composition. The function calls the drive() and fly() methods defined in the protocols.

Practice

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

easy

A. Override methods from multiple protocols automatically

B. Create a new class that inherits from multiple classes

C. Define a protocol that inherits from a single class

D. Combine multiple protocols into one requirement using &

Solution

1. Step 1: Understand protocol composition concept

   Protocol composition uses the & symbol to combine multiple protocols into one requirement.

2. Step 2: Differentiate from class inheritance

   Swift does not support multiple class inheritance, but protocol composition allows combining multiple protocols.

3. Final Answer:

   Combine multiple protocols into one requirement using & -> Option D

4. Quick Check:

   Protocol composition = Combine protocols with & [OK]

Hint: Remember & joins protocols to require multiple behaviors [OK]

Common Mistakes:

• Confusing protocol composition with class inheritance
• Thinking protocols can inherit from classes
• Assuming protocol composition overrides methods

2. Which of the following is the correct syntax for protocol composition in Swift?

easy

A. protocol Combined = ProtocolA & ProtocolB

B. let combined: ProtocolA & ProtocolB

C. protocol Combined: ProtocolA & ProtocolB {}

D. class Combined: ProtocolA & ProtocolB {}

Solution

1. Step 1: Identify correct usage of protocol composition

   Protocol composition is used in type annotations like let variable: ProtocolA & ProtocolB.

2. Step 2: Check other options for syntax errors

   Options B and C misuse protocol inheritance or assignment syntax; D tries class inheritance from protocols incorrectly.

3. Final Answer:

   let combined: ProtocolA & ProtocolB -> Option B

4. Quick Check:

   Protocol composition syntax = type annotation with & [OK]

Hint: Use & in type declarations, not in protocol inheritance [OK]

Common Mistakes:

• Trying to inherit protocols with & in protocol declaration
• Using = instead of : or &
• Using class inheritance syntax with protocols

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

protocol A { func foo() }
protocol B { func bar() }
struct S: A, B {
  func foo() { print("foo") }
  func bar() { print("bar") }
}
func test(x: A & B) {
  x.foo()
  x.bar()
}
let s = S()
test(x: s)

medium

A. bar

B. foo

C. foo
bar

D. Compilation error

Solution

1. Step 1: Understand protocol composition parameter

   The function test requires an argument conforming to both protocols A and B.

2. Step 2: Check struct S conformance and method calls

   S conforms to both A and B, so calling foo() and bar() prints "foo" and "bar" respectively.

3. Final Answer:

   foo bar -> Option C

4. Quick Check:

   Both protocol methods called = foo and bar printed [OK]

Hint: Both protocols' methods run when composed type passed [OK]

Common Mistakes:

• Assuming only one protocol's method runs
• Thinking protocol composition causes errors
• Confusing struct conformance with protocol composition

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

protocol P1 { func p1() }
protocol P2 { func p2() }
func doSomething(x: P1 & P2) {
  x.p1()
  x.p2()
}
struct MyStruct: P1 {
  func p1() { print("p1") }
}
doSomething(x: MyStruct())

medium

A. MyStruct does not conform to P2, so cannot be passed to doSomething

B. Syntax error in protocol composition declaration

C. Missing implementation of p2() in doSomething function

D. doSomething should accept only one protocol, not composition

Solution

1. Step 1: Check struct conformance to protocols

   MyStruct conforms only to P1, missing P2 conformance.

2. Step 2: Understand function parameter requirement

   doSomething requires an argument conforming to both P1 and P2, so MyStruct instance is invalid.

3. Final Answer:

   MyStruct does not conform to P2, so cannot be passed to doSomething -> Option A

4. Quick Check:

   Protocol composition requires all protocols conformed [OK]

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

Common Mistakes:

• Passing instance conforming to only one protocol
• Thinking protocol composition allows partial conformance
• Ignoring compiler errors about missing protocol methods

5. Given these protocols and structs:

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

Which code snippet correctly uses protocol composition to accept only Drawable and Colorful types?

hard

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

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

C. func render(item: Drawable) where item: Colorful { item.draw() }

D. func render(item: Drawable & Colorful) where item.color != "" { item.draw() }

Solution

1. Step 1: Identify correct protocol composition syntax

   func render(item: Drawable & Colorful) { item.draw() } uses Drawable & Colorful correctly in parameter type.

2. Step 2: Check other options for syntax or logic errors

   func render(item: Drawable | Colorful) { item.draw() } uses | which is invalid; C misuses where clause syntax; D uses where clause incorrectly on parameter.

3. Final Answer:

   func render(item: Drawable & Colorful) { item.draw() } -> Option A

4. Quick Check:

   Use & to combine protocols in function parameters [OK]

Hint: Use & to combine protocols in parameter types, not | or where [OK]

Common Mistakes:

• Using | instead of & for protocol composition
• Misusing where clauses in parameter declarations
• Trying to filter protocol properties in parameter signature