Generic subscripts in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a generic subscript that returns the element at the given index.

Swift

struct Container<T> {
    var items: [T]
    subscript(index: Int) -> T {
        return items[1]index
    }
}

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

A{index}

B(index)

C[index]

D<index>

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of square brackets for subscripts.

Using curly braces or angle brackets which are invalid here.

In Swift, subscripts use square brackets to access elements by index.

2fill in blank

medium

Complete the generic subscript to accept a key of any Hashable type and return an optional value.

Swift

struct DictionaryWrapper<Value> {
    private var data: [String: Value]
    subscript<Key: Hashable>(key: Key) -> Value? {
        return data[[1]]
    }
}

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

Akey.description

Bkey

CString(key)

DString(describing: key)

Attempts:

3 left

💡 Hint

Common Mistakes

Using key directly which may not be a String.

Using key.description which may not exist for all Hashable types.

Since data keys are Strings, we convert the generic key to String using String(describing: key).

3fill in blank

hard

Fix the error in the generic subscript to correctly set a value for a given key.

Swift

struct Storage<Value> {
    private var items = [String: Value]()
    subscript<Key: Hashable>(key: Key) -> Value? {
        get {
            return items[String(describing: key)]
        }
        set {
            items[[1]] = newValue
        }
    }
}

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

AString(describing: key)

BString(key)

Ckey

Dkey.description

Attempts:

3 left

💡 Hint

Common Mistakes

Using key directly which causes type mismatch.

Using key.description which may not be available.

To set the value, the key must be converted to String using String(describing: key) to match the dictionary keys.

4fill in blank

hard

Fill both blanks to create a generic subscript that returns the count of elements if the key matches the type.

Swift

struct CollectionWrapper {
    var data: [String: Any]
    subscript<T>(key: String) -> Int? {
        if let collection = data[[1]] as? T {
            return (collection as? Collection)[2]count
        }
        return nil
    }
}

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

Akey

Bself.key

C.

D->

Attempts:

3 left

💡 Hint

Common Mistakes

Using self.key which is invalid here.

Using '->' instead of '.' to access properties.

Use 'key' to access the dictionary and '.' to access the count property of the collection.

5fill in blank

hard

Fill all three blanks to implement a generic subscript that sets and gets values with type safety.

Swift

struct TypedStorage {
    private var storage = [String: Any]()
    subscript<T>(key: String) -> T? {
        get {
            return storage[[1]] as? T
        }
        set {
            storage[[2]] = newValue
        }
    }
    func containsKey(_ key: String) -> Bool {
        return storage.keys.contains([3])
    }
}

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

Akey

B"key"

Dstorage

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string literal "key" instead of the variable key.

Using storage instead of key in keys.contains.

Use the parameter 'key' to access and set values in storage, and check if 'key' exists in keys.

Practice

1. What is the main benefit of using generic subscripts in Swift?

easy

A. They allow subscripts to accept different types as keys or indexes.

B. They make subscripts run faster by using fixed types only.

C. They restrict subscripts to only integer indexes.

D. They automatically convert all keys to strings.

Solution

1. Step 1: Understand generic subscripts purpose

   Generic subscripts let you write one subscript that works with many types of keys or indexes.

2. Step 2: Compare options with this purpose

   Only They allow subscripts to accept different types as keys or indexes. correctly states that generic subscripts accept different types as keys or indexes.

3. Final Answer:

   They allow subscripts to accept different types as keys or indexes. -> Option A

4. Quick Check:

   Generic subscripts = flexible key types [OK]

Hint: Generic subscripts = flexible keys/indexes [OK]

Common Mistakes:

• Thinking generic subscripts improve speed
• Assuming subscripts only accept integers
• Believing keys auto-convert to strings

2. Which of the following is the correct syntax to declare a generic subscript in Swift?

easy

A. subscript(index: T) -> String { get }

B. func subscript<T>(index: T) -> String { get }

C. subscript<T>(index: Int) -> T { get }

D. subscript<T>(index: T) -> String { get }

Solution

1. Step 1: Recall generic subscript syntax

   Generic subscripts use subscript<T>(index: T) -> ReturnType syntax.

2. Step 2: Check each option

   subscript<T>(index: T) -> String { get } matches the correct syntax. func subscript<T>(index: T) -> String { get } wrongly uses func. subscript(index: T) -> String { get } misses generic parameter declaration. subscript<T>(index: Int) -> T { get } has mismatched types.

3. Final Answer:

   subscript<T>(index: T) -> String { get } -> Option D

4. Quick Check:

   Generic subscript syntax = subscript<T> [OK]

Hint: Generic subscript uses subscript<T>(index: T) syntax [OK]

Common Mistakes:

• Using func instead of subscript
• Omitting generic parameter <T>
• Mismatching parameter and return types

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

struct Box {
    private var values = [String: Any]()
    subscript<T>(key: String) -> T? {
        get { values[key] as? T }
        set { values[key] = newValue }
    }
}

var box = Box()
box["age"] = 30
box["name"] = "Alice"
print(box["age"] as Int?, box["name"] as String?)

medium

A. Optional(30) Optional("Alice")

B. 30 Alice

C. nil nil

D. Compilation error

Solution

1. Step 1: Understand subscript behavior

   The subscript stores values in a dictionary with String keys and Any values, casting on get.

2. Step 2: Analyze stored values and prints

   "age" stores 30 (Int), "name" stores "Alice" (String). The print casts them back to Int? and String?, so output shows optionals.

3. Final Answer:

   Optional(30) Optional("Alice") -> Option A

4. Quick Check:

   Generic subscript returns optional cast values [OK]

Hint: Generic subscript returns optional cast values [OK]

Common Mistakes:

• Expecting non-optional output
• Confusing dictionary storage with direct types
• Assuming compilation error due to Any type

4. Identify the error in this generic subscript code and choose the fix:

struct Container {
    private var data = [Int: String]()
    subscript<T>(key: T) -> String? {
        get { data[key] }
        set { data[key] = newValue }
    }
}

medium

A. Change dictionary to [T: String] to match generic key type.

B. Add type constraint to subscript declaration.

C. Change subscript to subscript(key: Int) -> String? to match dictionary key type.

D. No error; code works as is.

Solution

1. Step 1: Check dictionary key type vs subscript key type

   Dictionary keys are Int, but subscript uses generic T which can be any type.

2. Step 2: Identify mismatch causing error

   Accessing data[key] fails because key is T, not necessarily Int. Fix is to restrict subscript key to Int.

3. Final Answer:

   Change subscript to subscript(key: Int) -> String? to match dictionary key type. -> Option C

4. Quick Check:

   Subscript key type must match dictionary key type [OK]

Hint: Subscript key type must match dictionary key type [OK]

Common Mistakes:

• Assuming generic T works without constraints
• Trying to change dictionary type without reason
• Ignoring type mismatch errors

5. Given a struct that stores values with keys of any Hashable type, how can you implement a generic subscript to safely get and set values?
Choose the best approach.

hard

A. Use separate dictionaries for each key type and switch inside the subscript.

B. Use a dictionary with keys of type AnyHashable and cast keys inside the subscript.

C. Use a dictionary with keys of type String only and convert all keys to String.

D. Use a generic dictionary [T: Any] without constraints and force cast keys.

Solution

1. Step 1: Understand requirement for any Hashable key

   To store values with keys of any Hashable type, use a dictionary with keys of type AnyHashable.

2. Step 2: Implement generic subscript with safe casting

   Use generic subscript with key of type T: Hashable, convert key to AnyHashable for dictionary access, ensuring type safety.

3. Final Answer:

   Use a dictionary with keys of type AnyHashable and cast keys inside the subscript. -> Option B

4. Quick Check:

   AnyHashable dictionary + generic subscript = safe flexible keys [OK]

Hint: Use AnyHashable keys for flexible generic subscripts [OK]

Common Mistakes:

• Using multiple dictionaries instead of one
• Converting all keys to String losing type info
• Force casting keys causing runtime errors