Understanding Swift extension usage in your API design

Question

The Alamofire API has extensions such as extension Request in ResponseSerialization.swift. When designing a Swift API why would you take this approach as opposed to just adding these methods to the Request class (Request.swift)?

I understand the use of extensions to extend API's when you don't control the source. This question is about using them to extend your own API.

Answer 1

For cleanliness or adding functionality to other classes you didn't create (i.e. extension UIColor). You can create separate extensions to add in separate bits of functionality.

For example, if you have a UIViewController and you add a table view to it's view, instead of making the declaration of ViewController look like this:

class ViewController : UIViewController, UITableViewDataSource, UITableViewDelegate

you could separate it all with extensions so you don't clutter your ViewController file.

Like so:

extension ViewController : UITableViewDataSource, UITableViewDelegate

which you could separate from the main body of the ViewController class or extract into a new file.

Answer 2

Extensions are one of the best features of Swift programming language and there are several use cases for them. Once you hold a grip of them you can come up with some really good and understandable code. Some of the use cases are:

1. Extending system types

With Swift you can any system type like Int or String to make some code more readable and to get some more functionality you would otherwise have to write on your own. For example, check out following code that repeats some task a number of times:

extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
}

Instead of creating separate function for task repetition and managing several parameters you can just extend Int and make it more readable:

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

// Hello!
// Hello!
// Hello!

Everybody can agree that this is the simplest and cleanest code you can ever create.

2. Make messy code readable

Check the following definition:

class MyTableViewController: UIViewController, UITableViewDelegate, UITableViewDataSource, CLLocationManagerDelegate {
   // a lot of functions 
}

If you put everything inside one class or structure, code will get messy at one point and it'll be hard to track which method belongs to which protocol or class. Instead you should be using this:

class MyTableViewController: UIViewController {
}

extension MyTableViewController: UITableViewDelegate {
}

extension MyTableViewController: UITableViewDataSource {
}

// etc...

3. Protocol extensions

Protocol extension are one of the coolest features of Swift. They enable adding methods to any class that adopts the protocol you are extending. For example let's extend CollectionType protocol.

extension CollectionType {
   func printAll() {
      print(self)
   }
}

Now you can use method printAll() on any structure that adopt this protocol! Some of them are native Swift types like Array, Dictionary or Set.

These are just some of the main usages of extensions and they can do a lot more:

• Add computed instance properties and computed type properties
• Define instance methods and type methods
• Provide new initializers
• Define subscripts
• Define and use new nested types
• Make an existing type conform to a protocol