Extensions with constraints in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to extend Array only when its elements conform to Equatable.

Swift

extension Array where Element: [1] {
    func containsElement(_ element: Element) -> Bool {
        return self.contains(element)
    }
}

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

AHashable

BComparable

CEquatable

DCodable

Attempts:

3 left

💡 Hint

Common Mistakes

Using a protocol that doesn't support equality checking like Comparable.

Forgetting to add the constraint after 'where Element:'.

The extension applies only when the array's elements conform to Equatable, allowing use of the contains method.

2fill in blank

medium

Complete the code to add a method only for Dictionary where Key is String.

Swift

extension Dictionary where [1] == String {
    func allKeys() -> [String] {
        return Array(self.keys)
    }
}

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

AKey

BElement

CSelf

DValue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Value' instead of 'Key' in the constraint.

Using 'Element' which is not a dictionary type alias.

The extension applies only when the Key type of the dictionary is String.

3fill in blank

hard

Fix the error in the extension to add a method only when Element conforms to Numeric.

Swift

extension Array where Element: [1] {
    func sum() -> Element {
        return self.reduce(0, +)
    }
}

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

ACodable

BComparable

CEquatable

DNumeric

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Comparable' which does not guarantee addition.

Using 'Equatable' which only supports equality checks.

The sum method requires elements to conform to Numeric so that addition and zero are defined.

4fill in blank

hard

Fill both blanks to extend Sequence only when Element is Hashable and add a method to get unique elements.

Swift

extension Sequence where [1]: [2] {
    func uniqueElements() -> [Element] {
        var seen = Set<Element>()
        return self.filter { seen.insert($0).inserted }
    }
}

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

AElement

BHashable

CEquatable

DComparable

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Equatable' instead of 'Hashable' which is needed for Set.

Using 'Sequence' instead of 'Element' in the constraint.

The extension requires the Element to conform to Hashable so it can be stored in a Set to filter unique values.

5fill in blank

hard

Fill all three blanks to extend Optional only when Wrapped is Comparable and add a method to compare with another Optional.

Swift

extension Optional where [1]: [2] {
    func isGreater(than other: Optional<[3]>) -> Bool {
        switch (self, other) {
        case let (.some(a), .some(b)):
            return a > b
        default:
            return false
        }
    }
}

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

AWrapped

BComparable

DEquatable

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Equatable' instead of 'Comparable' which does not support > operator.

Using 'Optional' instead of 'Wrapped' in the constraint.

The extension applies when Wrapped type conforms to Comparable. The method compares two optionals by unwrapping and comparing their values.

Practice

1. What is the main purpose of using where in Swift extensions with constraints?

easy

A. To override existing methods in a class

B. To create a new class from an existing one

C. To add functionality only to types that meet specific conditions

D. To declare a variable inside an extension

Solution

1. Step 1: Understand the role of where in extensions

   The where keyword is used to specify conditions that types must meet to gain the added functionality.

2. Step 2: Recognize the purpose of constraints

   Constraints ensure that only types matching the condition get the new methods or properties, keeping code safe and organized.

3. Final Answer:

   To add functionality only to types that meet specific conditions -> Option C

4. Quick Check:

   Extensions with where add features conditionally = A [OK]

Hint: Remember: where limits extension to certain types [OK]

Common Mistakes:

• Thinking where creates new classes
• Confusing extensions with inheritance
• Using where to declare variables

2. Which of the following is the correct syntax to extend Array only when its elements conform to the Equatable protocol?

easy

A. extension Array where Element == Equatable { }

B. extension Array if Element == Equatable { }

C. extension Array with Element: Equatable { }

D. extension Array where Element: Equatable { }

Solution

1. Step 1: Recall correct syntax for constrained extensions

   Swift uses where followed by the condition, e.g., Element: Equatable to constrain extensions.

2. Step 2: Identify the correct option

   extension Array where Element: Equatable { } uses the correct syntax: extension Array where Element: Equatable { }. Others misuse if, ==, or with.

3. Final Answer:

   extension Array where Element: Equatable { } -> Option D

4. Quick Check:

   Use where and colon for protocol conformance = C [OK]

Hint: Use where Type: Protocol for constraints [OK]

Common Mistakes:

• Using == instead of : for protocol conformance
• Replacing where with if
• Writing with instead of where

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

extension Collection where Element: Numeric {
    func sum() -> Element {
        reduce(0, +)
    }
}

let numbers = [1, 2, 3, 4]
print(numbers.sum())

medium

A. 0

B. 10

C. Error: sum() not found

D. 1234

Solution

1. Step 1: Understand the extension constraint

   The extension adds a sum() method only to collections whose elements conform to Numeric. Array of Int fits this.

2. Step 2: Calculate the sum of the array

   The sum() method uses reduce(0, +) which adds all elements: 1+2+3+4 = 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Sum of [1,2,3,4] = 10 [OK]

Hint: Check if element type matches constraint to use extension methods [OK]

Common Mistakes:

• Assuming sum() works on non-Numeric elements
• Thinking sum() concatenates numbers
• Ignoring the extension constraint

4. Identify the error in this Swift extension:

extension Array where Element == Int {
    func multiplyAll() -> Int {
        reduce(1, *)
    }
}

medium

A. reduce(1, *) is invalid syntax

B. Cannot use == to check type equality in extension constraints

C. Missing return keyword in multiplyAll()

D. Array cannot be extended with constraints

Solution

1. Step 1: Check extension constraint syntax

   Swift requires Element: SomeProtocol or Element == SomeType is valid only for type equality, but for generic parameters, Element == Int is allowed.

2. Step 2: Verify if Element == Int is valid here

   Actually, Element == Int is valid syntax for type equality constraints in extensions, so Cannot use == to check type equality in extension constraints is incorrect.

3. Step 3: Check other options

   Missing return keyword in multiplyAll(): The function uses implicit return allowed in single-expression functions, so no error.
   reduce(1, *) is invalid syntax: reduce(1, *) is invalid syntax because the operator * cannot be passed as a bare argument like that.
   Array cannot be extended with constraints: Arrays can be extended with constraints.

4. Step 4: Re-examine Cannot use == to check type equality in extension constraints

   In Swift 5+, Element == Int is valid. So no syntax error here.

5. Final Answer:

   reduce(1, *) is invalid syntax -> Option A

6. Quick Check:

   Operator * must be passed as a closure or function, not bare = B [OK]

Hint: Remember: Element == Type is valid for type equality [OK]

Common Mistakes:

• Thinking == is invalid in extension constraints
• Expecting explicit return in single-expression functions
• Misreading reduce syntax

5. You want to add a method isAllEqual() to arrays only when their elements conform to Equatable. Which extension correctly implements this method to return true if all elements are equal, or false otherwise?

hard

A. extension Array where Element: Equatable {
func isAllEqual() -> Bool {
guard let first = self.first else { return true }
return allSatisfy { $0 == first }
}
}

B. extension Array where Element == Equatable {
func isAllEqual() -> Bool {
for i in 1..

C. extension Array where Element: Equatable {
func isAllEqual() -> Bool {
for element in self {
if element != self[0] { return false }
}
return true
}
}

D. extension Array {
func isAllEqual() -> Bool {
for i in 1..

Solution

1. Step 1: Check the extension constraint correctness

   Only options A and C use where Element: Equatable, which is correct to add methods requiring equality checks.

2. Step 2: Analyze method implementation

   extension Array where Element: Equatable { func isAllEqual() -> Bool { guard let first = self.first else { return true } return allSatisfy { $0 == first } } } safely handles empty arrays by returning true and uses allSatisfy for clarity.
   extension Array where Element: Equatable { func isAllEqual() -> Bool { for element in self { if element != self[0] { return false } } return true } } compares each element to self[0] but does not handle empty arrays, which can cause runtime error.
   extension Array where Element == Equatable { func isAllEqual() -> Bool { for i in 1..Element == Equatable which is invalid syntax.
   extension Array { func isAllEqual() -> Bool { for i in 1..

3. Final Answer:

   Option A correctly implements isAllEqual() with proper constraint and safe code -> Option A

4. Quick Check:

   Use where Element: Equatable and safe checks = A [OK]

Hint: Use where Element: Equatable and safe first element check [OK]

Common Mistakes:

• Using Element == Equatable instead of Element: Equatable
• Not handling empty arrays safely
• Extending without constraints for Equatable methods