Protocol Oriented Programming in Swift

Object Oriented Programming is a paradigm used by programmers many decaded to solve computer problems by modeling them in to classes. In Swift 2.0 a new programming pattern has been introduced known as Protocol Oriented Programming. In this article, we will the three major feature as part of Protocol Oriented Programming

  • Modeling with Protocols and Structs
  • Protocol Extension
  • Swift Standard Library Extension

Using Protocols and Structs

Let us see an example by modeling Bicylce, MotorBike and Car with Protocols and Structs. Create Vehicle and MotorVehicle protocol with the following property definition

protocol Vehicle {
    var speed: Int {get}
    var color: String {get}
    var yearOfMake: Int {get}
}

protocol MotorVehicle {
    var engineSize: Int {get}
    var licensePlate: String {get}
}

In Swift we can make any type (Class. Struct, Enums) to conform to a Protocol. Let us go for a value type (Struct) and not class as we are moving away from inheritance. And it is always safe to use value type and avoid memory related issues by using object references (Class).

struct Bicyle: Vehicle {
    let speed: Int
    let color: String
    let yearOfMake: Int
}

struct MotorBike: MotorVehicle, Vehicle {
    let speed: Int
    let color: String
    let engineSize: Int
    let licensePlate: String
    let yearOfMake: Int
}
struct Car: MotorVehicle, Vehicle  {
    let speed: Int
    let color: String
    let engineSize: Int
    let licensePlate: String
    let numberOfDoors: Int
    let yearOfMake: Int
}

In the above code snippet, we have created three strutcs Bicycle, MotorBike and Car. Bicyle conforms to Vehicle but Car and MotorBike conform to both Vehicle and MotorVehicle. Now start creating Cars, Bicycles and MotorBikes using corresponding structs.

let cycle = Bicyle(speed: 10, color: "Blue",yearOfMake: 2011)
let bike = MotorBike(speed: 65, color: "Red", engineSize: 100, licensePlate: "HT-12345",yearOfMake: 2015)
let bmw = Car(speed: 220, color: "Green", engineSize: 1200, licensePlate: "FC-20 435", numberOfDoors: 4,yearOfMake: 2016)
let audi = Car(speed: 220, color: "Cyan", engineSize: 1200, licensePlate: "FC-41 234", numberOfDoors: 4,yearOfMake: 2013)

Protocol Extension

In Swift 2.0, the real power Protocol comes with its ability to add extension. It is not just adding method definition but now Protocol allows you to add implemenation as well. Let us say you want to compare vehicles based on yearOfMake attribute. All you need to do is to add an extension for Vehicle Protocol

extension Vehicle {
    func isNewer(item: Vehicle) -> Bool {
        return self.yearOfMake > item.yearOfMake
    }
}
// comparing audi and bmw should return false
audi.isNewer(bmw)

Swift Standard Library Extension

You can also add extension to Swift standard library such CollectionType, Range, Array etc.. Let us take the following scenario where you have an array of MotorBikes and want to filter them based on licensePlate information.

let bike1 = MotorBike(speed: 65, color: "Red", engineSize: 100, licensePlate: "HT-12345",yearOfMake: 2015)
let bike2 = MotorBike(speed: 75, color: "Black", engineSize: 120, licensePlate: "RV-453",yearOfMake: 2013)
let bike3 = MotorBike(speed: 55, color: "Blue", engineSize: 80, licensePlate: "XY-5 520",yearOfMake: 2012)
let bike4 = MotorBike(speed: 55, color: "Red", engineSize: 80, licensePlate: "XY-7 800",yearOfMake: 2009)

let motorbikes = [bike1,bike2, bike3, bike4]

How about filtering of all Small Mopeds based on licensePlate containing “XY” characters. This can be achieved by adding an extension to CollectionType which conforms to MotorVehicle protocol. Then create a new function “filterLicensePlate” as shown below

extension CollectionType where Generator.Element:MotorVehicle {
    func filterLicensePlate(match:String -> [Generator.Element] {
        var result:[Generator.Element] = []
        for item in self {
            if item.licensePlate.containsString(match) {
                result.append(item)
            }
        }
        return result
    }
} 
let motorbikes = [bike1,bike2, bike3, bike4]
// fiter only small mopeds based on XY
motorbikes.filterLicensePlate("XY").count

Hope you found this introduction to Protocol Oriented Programming useful. Please use the comment section to add your feedback/suggestion.

References

WWDC 2015 – Protocol Oriented Programming
Mixing and Traits in Swift 2.0
Protocol-Oriented Programming in Swift 2
Introducing Protocol-Oriented Programming in Swift 2

In Category: Swift 2

Ravi Shankar

A polyglot software developer and now exploring Swift and iOS development. If you would like to learn from me then check out services page.

Show 0 Comments
No comments yet. Be the first.

Leave a Comment