Protocol with associated types in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a protocol with associated types in Swift?

A protocol with associated types defines a placeholder type that is used as part of the protocol. It lets the protocol work with types that are not specified until the protocol is adopted.

beginner

How do you declare an associated type in a Swift protocol?

Use the keyword associatedtype followed by the name of the placeholder type inside the protocol definition.

beginner

Why use associated types in protocols?

They allow protocols to be flexible and work with different types without specifying exact types upfront, making code more reusable and generic.

intermediate

What happens if a protocol with an associated type is used as a type directly?

You cannot use a protocol with associated types as a concrete type directly because the associated type is not specified. You must use generics or type erasure.

beginner

Show a simple example of a protocol with an associated type and a struct that adopts it.

Example:<br>

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

struct Box: Container {
  var items = [String]()
  mutating func add(_ item: String) {
    items.append(item)
  }
}

What keyword declares an associated type in a Swift protocol?

A func

B typealias

C var

D associatedtype

The keyword associatedtype is used to declare a placeholder type inside a protocol.

Can you use a protocol with associated types as a concrete type directly?

A No, never

B Only if the associated type is specified

C Yes, always

D Only in classes

No, you cannot use a protocol with associated types as a concrete type directly because the associated type is not specified. You must use generics or type erasure.

What is the main benefit of using associated types in protocols?

A To fix the type to Int

B To allow flexibility with different types

C To make protocols slower

D To avoid using generics

Associated types let protocols work with different types, making code flexible and reusable.

Which of these is a valid associated type declaration?

A var Item: Int

B func Item()

C associatedtype Item

D type Item = Int

The correct syntax is associatedtype Item inside a protocol.

If a protocol has an associated type, how do you usually use it?

A By creating a generic function or type constrained to that protocol

B By casting it to Any

C By ignoring the associated type

D By using it as a global variable

You use generics constrained to the protocol to specify the associated type.

Explain what a protocol with associated types is and why it is useful in Swift.

Think about how protocols can work with different types without fixing them.

Describe how you would implement a protocol with an associated type and use it in a struct.

Show a simple example with a container and an item type.