Conditional conformance in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the struct conform to Equatable only when T is Equatable.

Swift

struct Box<T> {{
    var value: T
}}
extension Box: Equatable where T: [1] {
    static func == (lhs: Box<T>, rhs: Box<T>) -> Bool {
        return lhs.value == rhs.value
    }
}

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

AComparable

BCodable

CHashable

DEquatable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Comparable instead of Equatable in the where clause.

Forgetting the where clause entirely.

Trying to conform without constraints.

The extension makes Box conform to Equatable only if T itself conforms to Equatable.

2fill in blank

medium

Complete the code to make the generic enum conform to CustomStringConvertible only when T conforms to CustomStringConvertible.

Swift

enum Result<T> {{
    case success(T)
    case failure(Error)
}}
extension Result: CustomStringConvertible where T: [1] {
    var description: String {
        switch self {
        case .success(let value):
            return "Success: \(value.description)"
        case .failure(let error):
            return "Failure: \(error.localizedDescription)"
        }
    }
}

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

ACustomStringConvertible

BCodable

CEquatable

DHashable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Codable instead of CustomStringConvertible.

Not adding the where clause.

Trying to use description without the constraint.

The enum Result conforms to CustomStringConvertible only if T does, so it can use value.description safely.

3fill in blank

hard

Fix the error in the code by completing the where clause to make the struct conform to Hashable only when T is Hashable.

Swift

struct Wrapper<T> {{
    var item: T
}}
extension Wrapper: Hashable where T: [1] {
    func hash(into hasher: inout Hasher) {
        hasher.combine(item)
    }
}

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

AEquatable

BCodable

CHashable

DComparable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Equatable instead of Hashable in the where clause.

Omitting the where clause.

Trying to hash without T being Hashable.

To conform to Hashable, the generic type T must also conform to Hashable.

4fill in blank

hard

Fill both blanks to make the generic struct conform to Codable only when T conforms to Codable.

Swift

struct Container<T> {{
    var content: T
}}
extension Container: Codable where T: [1] & [2] {
    // Codable conformance is automatic here
}

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

AEncodable

BHashable

CDecodable

DEquatable

Attempts:

3 left

💡 Hint

Common Mistakes

Using only Encodable or only Decodable.

Using unrelated protocols like Hashable or Equatable.

Not using the & operator to combine constraints.

Codable is a typealias for Encodable & Decodable, so both constraints are needed for conditional conformance.

5fill in blank

hard

Fill all three blanks to create a generic struct that conforms to Comparable only when T conforms to Comparable, and implement the < operator.

Swift

struct Pair<T> {{
    var first: T
    var second: T
}}
extension Pair: Comparable where T: [1] {
    static func < (lhs: Pair<T>, rhs: Pair<T>) -> Bool {
        if lhs.first [2] rhs.first {
            return true
        } else if lhs.first == rhs.first {
            return lhs.second [3] rhs.second
        } else {
            return false
        }
    }
}

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

AComparable

B<

C>

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of < in comparisons.

Not constraining T to Comparable.

Using == instead of < for ordering.

The struct conforms to Comparable only if T does. The < operator compares first values, then second values if first are equal.

Practice

1. What does conditional conformance in Swift allow you to do?

easy

A. Make a generic type conform to a protocol only if its generic parameters conform

B. Force all types to conform to a protocol regardless of their generic parameters

C. Automatically generate protocol methods without implementation

D. Conform a type to multiple protocols at once without conditions

Solution

1. Step 1: Understand generic types and protocols

   Generic types can have parameters that may or may not conform to protocols.

2. Step 2: Role of conditional conformance

   Conditional conformance allows a generic type to conform to a protocol only if its generic parameters also conform to that protocol.

3. Final Answer:

   Make a generic type conform to a protocol only if its generic parameters conform -> Option A

4. Quick Check:

   Conditional conformance = generic type depends on parameter conformance [OK]

Hint: Think: 'Conformance depends on generic parameters' [OK]

Common Mistakes:

• Assuming all generic types conform unconditionally
• Confusing conditional conformance with protocol inheritance
• Believing conditional conformance auto-implements methods

2. Which of the following is the correct syntax to declare conditional conformance for a generic struct Box to the protocol Equatable when its generic type T is Equatable?

easy

A. struct Box<T>: Equatable where T: Equatable {}

B. struct Box<T> where T: Equatable: Equatable {}

C. struct Box<T>: Equatable if T: Equatable {}

D. struct Box<T>: Equatable where T == Equatable {}

Solution

1. Step 1: Recall Swift conditional conformance syntax

   Use where clause after the protocol conformance list to specify conditions.

2. Step 2: Match syntax to options

   struct Box<T>: Equatable where T: Equatable {} correctly places where T: Equatable after : Equatable. Others misuse syntax keywords or order.

3. Final Answer:

   struct Box<T>: Equatable where T: Equatable {} -> Option A

4. Quick Check:

   Correct syntax uses 'where' after protocol list [OK]

Hint: Remember: 'where' clause follows protocol conformance [OK]

Common Mistakes:

• Placing 'where' before protocol conformance
• Using 'if' instead of 'where'
• Using '==' instead of ':' in constraints

3. Consider the following Swift code:

struct Wrapper<T> {}
extension Wrapper: Equatable where T: Equatable {
    static func ==(lhs: Wrapper<T>, rhs: Wrapper<T>) -> Bool {
        return true
    }
}

let a = Wrapper<Int>()
let b = Wrapper<Int>()
print(a == b)

What will be the output?

medium

A. false

B. true

C. Compilation error due to missing Equatable conformance

D. Runtime error

Solution

1. Step 1: Check conditional conformance applicability

   Wrapper conforms to Equatable only if T conforms to Equatable. Int conforms to Equatable, so Wrapper<Int> conforms.

2. Step 2: Analyze equality operator implementation

   The == operator always returns true regardless of instance state.

3. Final Answer:

   true -> Option B

4. Quick Check:

   Conditional conformance applies, operator returns true [OK]

Hint: Check if generic type meets condition, then see operator logic [OK]

Common Mistakes:

• Assuming default Equatable implementation is used
• Thinking compilation fails without explicit Equatable conformance
• Expecting false because instances are different

4. Identify the error in this Swift code snippet:

struct Container<T> {}
extension Container: Hashable where T: Equatable {
    func hash(into hasher: inout Hasher) {
        // implementation
    }
}

medium

A. No error; code is correct

B. Missing 'static' keyword in hash(into:) method

C. Extension syntax is invalid; 'where' clause misplaced

D. Cannot conform to Hashable with only T: Equatable; T must be Hashable

Solution

1. Step 1: Understand Hashable requirements

   To conform to Hashable, all stored properties must be Hashable. Here, T must conform to Hashable, not just Equatable.

2. Step 2: Check the constraint in the code

   The code requires T: Equatable, which is insufficient for Hashable conformance.

3. Final Answer:

   Cannot conform to Hashable with only T: Equatable; T must be Hashable -> Option D

4. Quick Check:

   Hashable requires T: Hashable, not just Equatable [OK]

Hint: Hashable needs Hashable constraint, not just Equatable [OK]

Common Mistakes:

• Confusing Equatable with Hashable requirements
• Thinking 'hash(into:)' must be static
• Misplacing 'where' clause in extension

5. You want to make a generic struct Pair conform to Codable only if both generic types A and B conform to Codable. Which of the following is the correct way to declare this conditional conformance?

hard

A. extension Pair: Codable if A: Codable and B: Codable {}

B. extension Pair: Codable where A & B: Codable {}

C. extension Pair: Codable where A: Codable, B: Codable {}

D. extension Pair: Codable where A == Codable, B == Codable {}

Solution

1. Step 1: Understand multiple constraints in 'where' clause

   Swift allows multiple constraints separated by commas in the where clause.

2. Step 2: Match correct syntax

   extension Pair: Codable where A: Codable, B: Codable {} correctly uses where A: Codable, B: Codable. Others use invalid syntax like '&', 'if', or '==' for constraints.

3. Final Answer:

   extension Pair: Codable where A: Codable, B: Codable {} -> Option C

4. Quick Check:

   Multiple constraints separated by commas in 'where' [OK]

Hint: Use commas to separate multiple 'where' constraints [OK]

Common Mistakes:

• Using '&' instead of comma in where clause
• Using 'if' instead of 'where'
• Using '==' instead of ':' for constraints