Protocol as types in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a protocol in Swift?

A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. Classes, structs, or enums can adopt protocols to provide actual implementations.

beginner

How can a protocol be used as a type in Swift?

You can use a protocol as a type to declare variables, constants, or function parameters. This means the value can be any instance of a type that conforms to that protocol.

intermediate

Why use protocols as types instead of concrete types?

Using protocols as types allows for flexible and reusable code. It lets you write functions or variables that work with any type that meets the protocol’s requirements, not just one specific type.

intermediate

Can you store different types conforming to the same protocol in one array?

Yes! Because the protocol can be used as a type, you can create an array of that protocol type and store different concrete types that conform to it.

advanced

What happens if a protocol has associated types or Self requirements? Can it be used as a type?

Protocols with associated types or Self requirements cannot be used directly as types because the compiler needs to know the exact type. You can use generics or type erasure to work around this.

Which of the following can be used as a type in Swift?

A A protocol without associated types

B A protocol with associated types

C A protocol with Self requirements

D None of the above

Protocols without associated types or Self requirements can be used as types. Those with associated types or Self requirements cannot be used directly as types.

What does it mean to use a protocol as a type?

A You can create variables that hold any value conforming to that protocol

B You can only use the protocol to define new protocols

C You must use a concrete class or struct type

D Protocols cannot be used as types

Using a protocol as a type means variables or parameters can hold any instance of a type that conforms to that protocol.

Can you have an array of different types if they all conform to the same protocol?

A Only if the types inherit from the same class

B No, arrays must have elements of the same concrete type

C Yes, if the array is typed as the protocol

D Only if the protocol has no methods

An array typed as the protocol can hold different types that conform to that protocol.

Why might you choose to use a protocol as a type?

A To make code slower

B To write flexible code that works with many types

C To avoid using any methods or properties

D To force all types to be the same concrete type

Using protocols as types allows writing flexible and reusable code that works with any conforming type.

If a protocol has an associated type, can you declare a variable of that protocol type directly?

A Only if the associated type is Int

B Yes, always

C Only if the protocol has no methods

D No, you must use generics or type erasure

Protocols with associated types cannot be used directly as types; generics or type erasure are needed.

Explain how using a protocol as a type helps in writing flexible Swift code.

Think about how you can use one variable to hold many different types.

Describe the limitation of using protocols with associated types as types and how to work around it.

Consider why the compiler needs more information about the type.

Practice

1. What does it mean to use a protocol as a type in Swift?

easy

A. Any object that follows the protocol's rules can be used as that type.

B. Only classes can conform to the protocol.

C. Protocols can only be used to create new classes.

D. Protocols define stored properties for types.

Solution

1. Step 1: Understand what a protocol defines

   A protocol defines a set of rules or features that a type must implement.

2. Step 2: Using protocol as a type

   When a protocol is used as a type, any object that implements those rules can be assigned to that type.

3. Final Answer:

   Any object that follows the protocol's rules can be used as that type. -> Option A

4. Quick Check:

   Protocol as type means flexible object use = A [OK]

Hint: Protocol as type means any conforming object fits [OK]

Common Mistakes:

• Thinking protocols only apply to classes
• Believing protocols define stored properties
• Confusing protocol usage with inheritance

2. Which of the following is the correct way to declare a variable of a protocol type named Drawable?

easy

A. var shape: Drawable

B. var shape: Drawable()

C. var shape: Drawable = Drawable()

D. var shape: Drawable[]

Solution

1. Step 1: Understand protocol type declaration

   To declare a variable of a protocol type, use the protocol name without parentheses or brackets.

2. Step 2: Analyze options

   var shape: Drawable correctly declares a variable of type Drawable. Options A and B incorrectly try to instantiate a protocol, which is not allowed. var shape: Drawable[] uses invalid syntax.

3. Final Answer:

   var shape: Drawable -> Option A

4. Quick Check:

   Protocol type variable = var name: ProtocolName [OK]

Hint: Declare protocol type without parentheses or initialization [OK]

Common Mistakes:

• Trying to instantiate a protocol directly
• Using parentheses after protocol name
• Using array brackets incorrectly

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

protocol Greetable {
    func greet() -> String
}

struct Person: Greetable {
    func greet() -> String {
        "Hello"
    }
}

let greeter: Greetable = Person()
print(greeter.greet())

medium

A. greet()

B. Compile error

C. Person

D. Hello

Solution

1. Step 1: Understand protocol conformance

   Person struct conforms to Greetable and implements greet() returning "Hello".

2. Step 2: Using protocol as type and calling method

   Variable greeter is of type Greetable but holds a Person instance, so calling greet() returns "Hello".

3. Final Answer:

   Hello -> Option D

4. Quick Check:

   Protocol method call returns implemented string = Hello [OK]

Hint: Protocol variable calls conforming type's method [OK]

Common Mistakes:

• Expecting protocol name or method name as output
• Thinking protocol cannot be used as variable type
• Confusing compile error with runtime behavior

4. Identify the error in this Swift code using protocol as a type:

protocol Vehicle {
    func start()
}

class Car: Vehicle {
    func start() {
        print("Car started")
    }
}

var myVehicle: Vehicle = Vehicle()
myVehicle.start()

medium

A. Variable myVehicle should be a class, not protocol

B. Missing method implementation in Car

C. Cannot instantiate protocol directly with Vehicle()

D. start() method should return a value

Solution

1. Step 1: Check protocol instantiation

   Protocols cannot be instantiated directly, so Vehicle() causes an error.

2. Step 2: Analyze variable assignment

   Variable myVehicle must hold an instance of a type conforming to Vehicle, like Car(), not Vehicle() itself.

3. Final Answer:

   Cannot instantiate protocol directly with Vehicle() -> Option C

4. Quick Check:

   Protocols can't be created with () = Error [OK]

Hint: Protocols can't be instantiated directly [OK]

Common Mistakes:

• Trying to create an instance of a protocol
• Confusing protocol with class instantiation
• Ignoring method return types

5. Given the protocol and classes below, which code correctly stores different types conforming to Animal in an array and calls sound() on each?

protocol Animal {
    func sound() -> String
}

class Dog: Animal {
    func sound() -> String { "Bark" }
}

class Cat: Animal {
    func sound() -> String { "Meow" }
}

hard

A. let animals: [Animal] = [Dog(), Cat()]
for animal in animals {
print(animal.sound)
}

B. let animals: [Animal] = [Dog(), Cat()]
for animal in animals {
print(animal.sound())
}

C. let animals: [Dog] = [Dog(), Cat()]
for animal in animals {
print(animal.sound())
}

D. let animals = [Dog(), Cat()]
for animal in animals {
print(animal.sound())
}

Solution

1. Step 1: Understand protocol array usage

   To store different types conforming to Animal, declare array as [Animal].

2. Step 2: Call method correctly

   Use animal.sound() with parentheses to call the method. let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) } does this correctly.

3. Final Answer:

   let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) } -> Option B

4. Quick Check:

   Protocol array with method calls = let animals: [Animal] = [Dog(), Cat()] for animal in animals { print(animal.sound()) } [OK]

Hint: Use protocol array type and call methods with () [OK]

Common Mistakes:

• Using concrete type array instead of protocol type
• Calling method without parentheses
• Mixing incompatible types in array