0protocol Container { associatedtype Item mutating func append(_ item: Item) func count() -> Int } struct IntStack: Container { var items = [Int]() mutating func append(_ item: Int) { items.append(item) } func count() -> Int { items.count } }
| Step | Action | Evaluation | Result |
|---|---|---|---|
| 1 | Define protocol Container with associatedtype Item | Protocol expects Item type to be specified | Protocol ready for conformance |
| 2 | Define struct IntStack conforming to Container | IntStack must specify Item type | IntStack's Item is Int |
| 3 | Implement append(_ item: Int) | Method adds item to items array | items array updated |
| 4 | Implement count() -> Int | Returns number of items | Returns current count |
| 5 | Create IntStack instance | Instance created with empty items | items = [] |
| 6 | Call append(10) | Adds 10 to items | items = [10] |
| 7 | Call count() | Returns number of items | Returns 1 |
| 8 | Call append(20) | Adds 20 to items | items = [10, 20] |
| 9 | Call count() | Returns number of items | Returns 2 |
| 10 | End of example | No more actions | Execution complete |
| Variable | Start | After Step 6 | After Step 8 | Final |
|---|---|---|---|---|
| items | [] | [10] | [10, 20] | [10, 20] |
protocol ProtocolName {
associatedtype Item
func method(item: Item)
}
struct MyType: ProtocolName {
typealias Item = ConcreteType
func method(item: ConcreteType) { ... }
}
- Protocols with associated types define placeholders.
- Conforming types specify concrete types.
- Required methods use the associated type.What is the main purpose of a protocol with an associated type in Swift?
Which of the following is the correct syntax to declare an associated type named Item inside a protocol?
associatedtype.associatedtype Item, which is correct. protocol Example { typealias Item } uses outdated typealias which is invalid here. Options C and D are incorrect syntax.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] }
}
var stack = IntStack()
stack.append(10)
stack.append(20)
print(stack[1])What will be the output?
Identify the error in this Swift code snippet:
protocol DataSource {
associatedtype Data
func fetch() -> Data
}
struct IntSource: DataSource {
typealias Data = Int
func fetch() -> String {
return "Hello"
}
}typealias Data = Int but implements fetch() returning String, which does not match the associated type Data.You want to create a generic function printFirstItem that accepts any type conforming to the Container protocol below and prints its first item. Which is the correct way to write this function?
protocol Container {
associatedtype Item
var count: Int { get }
subscript(i: Int) -> Item { get }
}Container alone is invalid as a parameter type.Container, which is correct. func printFirstItem(_ container: Container) {
print(container[0])
} tries to use protocol as a type directly, which is invalid. func printFirstItem(_ container: Container<Item>) {
print(container[0])
} uses invalid syntax. func printFirstItem<C>(_ container: C) where C: Container, C.Item == String {
print(container[0])
} adds an extra constraint on Item being String, which is unnecessary here.Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.