0extension Array where Element: Numeric { func sum() -> Element { self.reduce(0, +) } } let numbers = [1, 2, 3] print(numbers.sum())
| Step | Code Line | Action | Condition/Check | Result/Output |
|---|---|---|---|---|
| 1 | extension Array where Element: Numeric | Declare extension with constraint | Check if Element conforms to Numeric | Extension applies only if true |
| 2 | func sum() -> Element | Define sum method | Inside constrained extension | Method available only if constraint met |
| 3 | let numbers = [1, 2, 3] | Create array instance | Array of Int (Int conforms to Numeric) | numbers is [1, 2, 3] |
| 4 | print(numbers.sum()) | Call sum() | Check if sum() exists for numbers | sum() exists, call proceeds |
| 5 | self.reduce(0, +) | Calculate sum | Add elements 1+2+3 | Result is 6 |
| 6 | print output | Print result | Output value | 6 |
| 7 | If array was ["a", "b"] | Try sum() | Element String does not conform to Numeric | sum() method unavailable, compile error |
| Variable | Start | After Step 3 | After Step 5 | Final |
|---|---|---|---|---|
| numbers | undefined | [1, 2, 3] | [1, 2, 3] | [1, 2, 3] |
| sum() | not defined | available (because Element is Int) | called, computes 6 | returns 6 |
Swift extensions can add methods only when types meet conditions. Use 'extension Type where Condition' to add constrained features. Methods inside run only if the constraint is true. Example: extension Array where Element: Numeric adds sum() only for numeric arrays. This helps add safe, specific functionality without changing original types.
where in Swift extensions with constraints?where in extensionswhere keyword is used to specify conditions that types must meet to gain the added functionality.where add features conditionally = A [OK]where limits extension to certain types [OK]where creates new classeswhere to declare variablesEquatable protocol?where followed by the condition, e.g., Element: Equatable to constrain extensions.extension Array where Element: Equatable { }. Others misuse if, ==, or with.where and colon for protocol conformance = C [OK]where Type: Protocol for constraints [OK]== instead of : for protocol conformancewhere with ifwith instead of whereextension Collection where Element: Numeric {
func sum() -> Element {
reduce(0, +)
}
}
let numbers = [1, 2, 3, 4]
print(numbers.sum())sum() method only to collections whose elements conform to Numeric. Array of Int fits this.sum() method uses reduce(0, +) which adds all elements: 1+2+3+4 = 10.extension Array where Element == Int {
func multiplyAll() -> Int {
reduce(1, *)
}
}Element: SomeProtocol or Element == SomeType is valid only for type equality, but for generic parameters, Element == Int is allowed.Element == Int is valid hereElement == Int is valid syntax for type equality constraints in extensions, so Cannot use == to check type equality in extension constraints is incorrect.reduce(1, *) is invalid syntax because the operator * cannot be passed as a bare argument like that.Element == Int is valid. So no syntax error here.Element == Type is valid for type equality [OK]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?where Element: Equatable, which is correct to add methods requiring equality checks.allSatisfy for clarity.self[0] but does not handle empty arrays, which can cause runtime error.isAllEqual() with proper constraint and safe code -> Option Awhere Element: Equatable and safe checks = A [OK]where Element: Equatable and safe first element check [OK]Element == Equatable instead of Element: EquatablePass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.