Why extensions add capability without modifying in Swift - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of extension adding method to struct

What is the output of this Swift code that uses an extension to add a method to a struct?

Swift

struct Rectangle {
    var width: Double
    var height: Double
}

extension Rectangle {
    func area() -> Double {
        return width * height
    }
}

let rect = Rectangle(width: 3, height: 4)
print(rect.area())

A 7.0

B 12.0

C Error: Method 'area' not found

D 0.0

💡 Hint

Extensions add methods without changing original struct code.

The extension adds the 'area' method to Rectangle. The method calculates width * height, so 3 * 4 = 12.0.

🧠 Conceptual

intermediate

Why extensions do not modify original type source

Why do Swift extensions add new capabilities without modifying the original type's source code?

A Because extensions replace the original type with a new type that includes added members

B Because extensions are compiled separately and only add new members at runtime

C Because extensions add new members at compile time without changing the original source code file

D Because extensions copy the original type and modify the copy instead

💡 Hint

Think about how extensions are part of the same type but declared outside original code.

Extensions add new members at compile time, extending the type's capabilities without changing the original source code file.

🔧 Debug

advanced

Why does this extension method cause a compile error?

Given this code, why does the extension method cause a compile error?

Swift

struct Circle {
    var radius: Double
}

extension Circle {
    mutating func doubleRadius() {
        radius *= 2
    }
}

let c = Circle(radius: 5)
c.doubleRadius()

A Because 'c' is a constant and cannot call a mutating method

B Because extensions cannot add mutating methods

C Because 'doubleRadius' must return a value

D Because 'radius' is immutable inside the extension

💡 Hint

Check how 'let' and 'var' affect mutating methods.

The variable 'c' is declared with 'let', making it immutable. Mutating methods require a mutable instance declared with 'var'.

📝 Syntax

advanced

Which extension syntax correctly adds a computed property?

Which option correctly adds a computed property 'isEven' to Int using an extension?

A

extension Int {
    func isEven() -> Bool {
        return self % 2 == 0
    }
}

B

extension Int {
    let isEven: Bool = self % 2 == 0
}

C

extension Int {
    var isEven() -> Bool {
        return self % 2 == 0
    }
}

D

extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}

💡 Hint

Computed properties use 'var' without parentheses.

Option D correctly defines a computed property 'isEven' with 'var' and no parentheses. Option D defines a method, not a property. Option D has invalid syntax for a property. Option D tries to assign a property directly, which is invalid in extensions.

🚀 Application

expert

How extensions enable protocol conformance without modifying original type

How can Swift extensions add protocol conformance to a type without modifying its original source code?

A By declaring the protocol conformance and implementing required methods inside an extension

B By subclassing the original type and adding protocol conformance in the subclass

C By copying the original type and adding protocol conformance to the copy

D By modifying the original source code to include protocol conformance

💡 Hint

Extensions can declare protocol adoption and implement methods.

Extensions can declare that a type conforms to a protocol and implement the required methods, all without changing the original source code.