Swift Extensions

extension String {
    var isEmail: Bool {
        contains("@") && contains(".")
    }
    func shout() -> String { uppercased() + "!" }
}

"ada@example.com".isEmail     // true
"hello".shout()               // HELLO!

• Inside the extension, self is the value the method was called on, and it can usually be left out.
• Extensions can add computed properties but not stored ones, because they can't change how much memory a value uses.
• Methods that change a struct value, such as Int or String, must be mutating, just like in the original type.

Extensions can add convenience initializers. On a struct, adding an init in an extension keeps the automatic memberwise initializer too:

struct Money { let pence: Int }
extension Money {
    init(pounds: Double) { self.pence = Int((pounds * 100).rounded()) }
}
Money(pence: 1999)       // still available
Money(pounds: 19.99)     // new

Extensions can also add nested types, such as an enum of options that belongs to the type, and static members like static let zero = Money(pence: 0).

A common Swift style is to add each protocol conformance in its own extension:

struct Product { let name: String; let price: Double }

extension Product: CustomStringConvertible {
    var description: String { "\(name) £\(price)" }
}

extension Product: Comparable {
    static func < (a: Product, b: Product) -> Bool { a.price < b.price }
}

This keeps related code together and makes it obvious which code exists to satisfy which protocol. It also lets you make types you don't own conform to your protocols.

A where clause limits an extension to certain cases:

extension Array where Element == Int {
    var total: Int { reduce(0, +) }
}
extension Collection where Element: Comparable {
    var isSorted: Bool { zip(self, dropFirst()).allSatisfy { $0 <= $1 } }
}

[1, 2, 3].total works, but ["a"].total doesn't exist, because the extension only applies to arrays of Ints. Extending a protocol like Collection gives the method to arrays, sets, strings and more at once.

A real-world extension you'll see in many projects adds a subscript that returns nil instead of crashing when a position doesn't exist:

extension Collection {
    subscript(safe index: Index) -> Element? {
        indices.contains(index) ? self[index] : nil
    }
}

let colours = ["red", "green"]
print(colours[safe: 1] ?? "none")    // green
print(colours[safe: 5] ?? "none")    // none

Extensions can add subscripts as well as methods and properties. Because this one extends the Collection protocol rather than Array, it works on arrays, array slices and other collections too. The safe: label makes the different behaviour obvious at the call site, so ordinary colours[5] still crashes where you'd expect it to.

Extensions often add small helpers that take a closure, which can make code read naturally:

extension Int {
    func times(_ action: () -> Void) {
        for _ in 0..<self { action() }
    }
}
3.times { print("Hip hip!") }

Here self is the number the method was called on. Use helpers like this sparingly, though: a team member reading 3.times has to find the extension to know what it does, while for _ in 0..<3 is understood by every Swift developer.