Swift Extensions

• Extensions add new functionality to existing class, structure, enumeration, or protocol types.
• Extensions enable retroactive modeling, allowing extension of types without original source code access.
• Swift extensions are similar to categories in Objective-C but lack names.
• Extensions can add computed instance and type properties.
• Extensions can define instance and type methods.
• Extensions can provide new initializers.
• Extensions can define subscripts.
• Extensions can define and use new nested types.
• Extensions can make an existing type conform to a protocol.
• Protocols can be extended to provide implementations or add functionality.

Extension Syntax

• Extensions are declared using the extension keyword.

extension SomeType {
    // new functionality to add to SomeType goes here
}

• Extensions can enable a type to adopt one or more protocols.

extension SomeType: SomeProtocol, AnotherProtocol {
    // implementation of protocol requirements goes here
}

• Extensions can extend generic types.
• Extensions can conditionally add functionality to a generic type using a generic where clause.

Computed Properties

• Extensions can add computed instance and type properties.

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
// Prints "One inch is 0.0254 meters"
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
// Prints "Three feet is 0.914399970739201 meters"

• Computed properties in extensions allow treating Double values as specific length units.
• The m property returns self, interpreting a Double of 1.0 as "one meter."
• Other unit properties convert values to meters (e.g., km multiplies by 1,000.0).
• ft property divides the Double value by 3.28084 to convert it from feet to meters.
• These properties are read-only and omit the get keyword for brevity.
• The return value is of type Double and can be used in mathematical calculations wherever a Double is accepted.

let aMarathon = 42.km + 195.m
print("A marathon is \(aMarathon) meters long")
// Prints "A marathon is 42195.0 meters long"

Initializers

• Extensions can add new initializers to existing types, enabling the use of custom types as initializer parameters.
• Extensions can add new convenience initializers to a class, but not designated initializers or deinitializers.
• Designated initializers and deinitializers must be part of the original class implementation.
• Extensions adding initializers to value types with default values can call the default and memberwise initializers from within the extension's initializer.

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
}

• Structures like Rect with default values for all properties automatically receive default and memberwise initializers.

let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
    size: Size(width: 5.0, height: 5.0))

• Extensions can provide additional initializers.

extension Rect {
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

• The new initializer calculates the origin point based on the center and size and then calls the memberwise initializer.

let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
    size: Size(width: 3.0, height: 3.0))
// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)

Methods

• Extensions can add new instance and type methods to existing types.

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0.. Void`, indicating a function with no parameters and no return value.
- The `repetitions(task:)` method can be called on any integer to perform a task a specific number of times.

3.repetitions { print("Hello!") } // Hello! // Hello! // Hello!

### Mutating Instance Methods
- Instance methods can modify the instance itself.
- Structure and enumeration methods that modify `self` or its properties must be marked as `mutating`.

extension Int { mutating func square() { self = self * self } } var someInt = 3 someInt.square() // someInt is now 9

### Subscripts
- Extensions can add new subscripts to an existing type.

extension Int { subscript(digitIndex: Int) -> Int { var decimalBase = 1 for _ in 0.. 0: return.positive default: return.negative } } }

- This adds a new nested enumeration to `Int` called `Kind`, expressing the number's sign.
- A new computed instance property called `kind` returns the appropriate `Kind` enumeration case for that integer.

func printIntegerKinds(_ numbers: [Int]) { for number in numbers { switch number.kind { case.negative: print("- ", terminator: "") case.zero: print("0 ", terminator: "") case.positive: print("+ ", terminator: "") } } print("") } printIntegerKinds([3, 19, -27, 0, -6, 0, 7]) // Prints "+ + - 0 - 0 + "

- The `printIntegerKinds(_:)` function takes an array of `Int` values and prints the sign of each integer.