Extensions in Swift can provide an elegant and organized way to add functionality to structs, enums, classes and protocols. They can add intent and readability to the code, paving the way for glowing Swift poetry, choirs of singing angels and world peace*.

A great way to get rolling with extensions is to see how they can be used to enhance an existing struct in the Swift standard library. This post will cover how to add simple computed properties and create an extension to group measurement unit conversions in an app.

*best case scenario

extension Double {
    
    var isEven: Bool {
        
        if (self % 2 == 0) {
            return true
        } else {
            return false
        }
    }
}

10.0.isEven // true
9.9.isEven  // false

// could then use the computed property in closures, for example

var myArray: [Double] = [9.8, 4.0, 7.6, 9.1, 8.0]

let newArray = myArray.map() { $0.isEven }

newArray    // [false, true, false, false, true]

let filteredArray = myArray.filter() { $0.isEven }

filteredArray    // [4, 8]

In this example, functionality has been added to extend the type Double by adding a computed property.  Once this extension is created .isEven can be used in place of writing out the test every time. Thus keeping the code nice and DRY.

There’s actually already a lot of functionality in the types included from Apple. It’s possible to get a quick idea of this by having a gander at the code completion window like so:

Mutation!

If you’d like the method or computed property within the extension to affect an existing stored value the keyword mutating must be added.

Very important: each time you use the keyword “mutating” you must give a realist enactment of transforming into a werewolf. (It’s not suitable for the workplace but the compiler does demand it).

extension Int {
    
    mutating func addNumber(number: Int) {
        self += number
    }
}

var distance = 7   // (must be a var if it's going to be mutated)

distance.addNumber(8)    // 15
distance.addNumber(3)    // 18
distance.addNumber(11)   // 29

// each call to the .addNumber() method mutates the existing stored property within the Int struct

Note: methods that already exist within the type can’t be overriden in an extension.

Above the type Double has been extended with a new method .addNumber() . However, it would not be possible, for example, to modify the existing .successor() method that Apple has already provided within the Int type.

Unit Conversions – No Sweat

Many different kinds of apps will require the ability to convert units of measurement. For example, in an app that calculates time/distance/pace in a triathlon there might be a number of different units used in the UI (miles, kilometers, meters, yards).  Having all the possible conversions as separate methods can become verbose. Extensions can offer a more elegant approach to group these together, eliminating “magic numbers” from the main calculation module.  The extension can then be stored in a separate Swift file that can be accessed by any module within the bundle.

extension Double {
    
    // For distance
    
    var metersToKm: Double { return self / 1000.0 }
    
    var metersToYd: Double { return self * 1.0936133 }
    
    var metersToMi: Double { return self / 1609.34 }
    
    var milesToMeters: Double { return self * 1609.34 }
    
    // For pace
    
    var secPerKmToSecPerMile: Double { return self * 1.60934 }
    
    var secPerMileToSecPerKm: Double { return self / 1.60934 }
    
}

// implementation in swift file designated for calculator brain

var distanceMeters: Double = 42195.0   // distance of a marathon

var distanceMiles = distanceMeters.metersToMi   // 26.2188...

Note: these are read only computed properties so they’re expressed without the get keyword.

In Summary

Beyond extending data model types in the Swift standard library, extensions can be used in many more ways, such as to:

• Add a new protocol onto an existing type (known as protocol conformance extension)
• Add functionality to any 3rd party API (without changing the source code)
• Group helper methods for model types you’ve created

Playground with the examples above can be found on GitHub here