Associated types in protocols in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an associated type in the protocol.

Swift

protocol Container {
    associatedtype [1]
}

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

AElement

BItem

CType

DValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a reserved keyword as the associated type name.

Forgetting to write 'associatedtype' before the name.

The keyword 'associatedtype' is followed by the name of the associated type, commonly 'Element'.

2fill in blank

medium

Complete the code to specify the associated type in a struct conforming to the protocol.

Swift

struct Stack: Container {
    typealias [1] = Int
    var items = [Int]()
}

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

AItem

BType

CElement

DValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different name than the protocol's associated type.

Omitting 'typealias' keyword.

To specify the associated type, use 'typealias' followed by the associated type name, which is 'Element'.

3fill in blank

hard

Fix the error in the protocol declaration by completing the associated type constraint.

Swift

protocol Container {
    associatedtype Element: [1]
}

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

ACodable

BComparable

CHashable

DEquatable

Attempts:

3 left

💡 Hint

Common Mistakes

Using a protocol that does not support equality comparison.

Omitting the constraint entirely.

The associated type 'Element' is constrained to conform to 'Equatable' to allow equality checks.

4fill in blank

hard

Fill both blanks to complete the generic function using the protocol with associated type.

Swift

func allItemsMatch<C1: Container, C2: Container>(_ someContainer: C1, _ anotherContainer: C2) -> Bool where C1.[1] == C2.[2] {
    // function body
    return false
}

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

AElement

BItem

CValue

DType

Attempts:

3 left

💡 Hint

Common Mistakes

Using different associated type names for the two containers.

Using a name not declared as an associated type.

Both containers must have the same associated type 'Element' to compare their items.

5fill in blank

hard

Fill all three blanks to complete the protocol and conforming struct with associated type and method.

Swift

protocol Container {
    associatedtype [1]
    mutating func append(_ item: [2])
    var count: Int { get }
    subscript(i: Int) -> [3] { get }
}

struct IntStack: Container {
    var items = [Int]()
    mutating func append(_ item: Int) {
        items.append(item)
    }
    var count: Int {
        items.count
    }
    subscript(i: Int) -> Int {
        items[i]
    }
}

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

AElement

BItem

CInt

DValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent type names between protocol and struct.

Not matching the associated type with method parameters and return types.

The protocol declares an associated type 'Element', and the methods use 'Element' which is 'Int' in the conforming struct.

Practice

1. What is the main purpose of associatedtype in a Swift protocol?

easy

A. To create a stored property inside the protocol

B. To define a placeholder type that conforming types will specify

C. To implement a method inside the protocol

D. To inherit from another protocol

Solution

1. Step 1: Understand the role of associatedtype

   The associatedtype keyword declares a placeholder type inside a protocol.

2. Step 2: Identify how conforming types use it

   Types that adopt the protocol specify the actual type for this placeholder, making the protocol flexible.

3. Final Answer:

   To define a placeholder type that conforming types will specify -> Option B

4. Quick Check:

   Associated types = Placeholder type [OK]

Hint: Remember: associatedtype is a placeholder type in protocols [OK]

Common Mistakes:

• Thinking associatedtype creates stored properties
• Confusing associatedtype with method implementation
• Assuming associatedtype inherits protocols

2. Which of the following is the correct syntax to declare an associated type named Item inside a protocol?

easy

A. protocol Example { typealias Item }

B. protocol Example { func Item() }

C. protocol Example { var Item: Int }

D. protocol Example { associatedtype Item }

Solution

1. Step 1: Recall the syntax for associated types

   The correct keyword to declare an associated type is associatedtype.

2. Step 2: Match the syntax with options

   protocol Example { associatedtype Item } uses associatedtype Item, which is the correct syntax inside a protocol.

3. Final Answer:

   protocol Example { associatedtype Item } -> Option D

4. Quick Check:

   Syntax for associatedtype = protocol Example { associatedtype Item } [OK]

Hint: Use 'associatedtype' keyword, not 'typealias' for protocols [OK]

Common Mistakes:

• Using typealias instead of associatedtype
• Declaring associated type as a variable
• Trying to declare associated type as a function

3. Consider the following Swift code:

protocol Container {
    associatedtype Item
    func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

struct IntStack: Container {
    var items = [Int]()
    mutating func append(_ item: Int) {
        items.append(item)
    }
    var count: Int { items.count }
    subscript(i: Int) -> Int {
        items[i]
    }
}

What is the type of Item for IntStack?

medium

A. String

B. Double

C. Int

D. Any

Solution

1. Step 1: Identify the associated type in the protocol

   The protocol Container has an associated type Item.

2. Step 2: Check the conforming type's implementation

   IntStack uses an array of Int and its append method accepts Int. So, Item is Int.

3. Final Answer:

   Int -> Option C

4. Quick Check:

   Associated type Item = Int in IntStack [OK]

Hint: Look at the type used in methods and properties for Item [OK]

Common Mistakes:

• Assuming Item is String by default
• Confusing associated type with protocol name
• Ignoring the concrete type used in the struct

4. Given the following code, what is the error?

protocol Container {
    associatedtype Item
    func append(_ item: Item)
}

struct StringStack: Container {
    var items = [String]()
    func append(_ item: Int) {
        items.append(String(item))
    }
}

medium

A. append method parameter type does not match associated type

B. Missing mutating keyword on append method

C. Associated type Item is not specified

D. items array type mismatch

Solution

1. Step 1: Check the protocol's associated type and method

   The protocol expects append(_ item: Item) where Item is the associated type.

2. Step 2: Compare with struct's append method

   StringStack has append(_ item: Int), but Item should be String because items is an array of String.

3. Step 3: Identify mismatch

   The parameter type Int does not match the expected String associated type.

4. Final Answer:

   append method parameter type does not match associated type -> Option A

5. Quick Check:

   Parameter type mismatch = append method parameter type does not match associated type [OK]

Hint: Check method parameter matches associated type exactly [OK]

Common Mistakes:

• Forgetting to mark append as mutating
• Ignoring parameter type mismatch
• Assuming associated type is Int automatically

5. You want to create a protocol PairContainer with two associated types First and Second. You want a function swap() that swaps the two values inside a conforming struct. Which of the following is the correct way to declare the protocol and implement swap() in a struct?

hard

A. protocol PairContainer {
associatedtype First
associatedtype Second
var first: First { get set }
var second: Second { get set }
mutating func swap()
}

struct Pair: PairContainer {
var first: Int
var second: Int
mutating func swap() {
(first, second) = (second, first)
}
}

B. protocol PairContainer {
associatedtype First
associatedtype Second
var first: First { get }
var second: Second { get }
func swap()
}

struct Pair: PairContainer {
var first: Int
var second: Int
func swap() {
let temp = first
first = second
second = temp
}
}

C. protocol PairContainer {
associatedtype First
associatedtype Second
var first: First { get set }
var second: Second { get set }
func swap()
}

struct Pair: PairContainer {
var first: Int
var second: Int
mutating func swap() {
(first, second) = (second, first)
}
}

D. protocol PairContainer {
associatedtype First
associatedtype Second
var first: First { get set }
var second: Second { get set }
mutating func swap()
}

struct Pair: PairContainer {
var first: Int
var second: Int
func swap() {
(first, second) = (second, first)
}
}

Solution

1. Step 1: Define protocol with mutable properties and mutating method

   The protocol requires first and second as get/set properties and a mutating func swap() to modify them.

2. Step 2: Implement struct with matching mutating swap method

   The struct Pair has mutable first and second properties and a mutating func swap() that swaps values correctly.

3. Step 3: Check other options for errors

   protocol PairContainer { associatedtype First associatedtype Second var first: First { get } var second: Second { get } func swap() } struct Pair: PairContainer { var first: Int var second: Int func swap() { let temp = first first = second second = temp } }'s properties are get-only and swap is non-mutating, so it cannot modify properties. protocol PairContainer { associatedtype First associatedtype Second var first: First { get set } var second: Second { get set } func swap() } struct Pair: PairContainer { var first: Int var second: Int mutating func swap() { (first, second) = (second, first) } } has non-mutating protocol method but mutating struct method, mismatch. protocol PairContainer { associatedtype First associatedtype Second var first: First { get set } var second: Second { get set } mutating func swap() } struct Pair: PairContainer { var first: Int var second: Int func swap() { (first, second) = (second, first) } } has mutating protocol method but non-mutating struct method, mismatch.

4. Final Answer:

   Protocol with { get set } properties and mutating func swap(), struct with mutating func swap() -> Option A

5. Quick Check:

   Mutating methods and get/set properties = protocol PairContainer { associatedtype First associatedtype Second var first: First { get set } var second: Second { get set } mutating func swap() } struct Pair: PairContainer { var first: Int var second: Int mutating func swap() { (first, second) = (second, first) } } [OK]

Hint: Mutating methods must be marked mutating in protocol and struct [OK]

Common Mistakes:

• Not marking swap as mutating in protocol or struct
• Using get-only properties when set is needed
• Mismatch between protocol and struct method mutability