How can you create reusable code with Swift protocols and extensions?

1 What are protocols?

Protocols are a way of defining a blueprint of methods, properties, and other requirements that suit a particular task or functionality. Protocols do not provide any implementation details or behavior; they only specify what an object that conforms to the protocol should do or have. For example, you can define a protocol called Printable that requires any conforming type to have a print() method that returns a String.

2 What are extensions?

Extensions are a way of adding new functionality or modifying existing functionality to an existing type, such as a class, struct, enum, or protocol. Extensions do not require you to modify the original source code of the type or inherit from it; you can simply extend it with new methods, properties, initializers, or subscripts. For example, you can extend the Int type with a new method called squared() that returns the square of the integer.

3 How to use protocols and extensions together?

One of the benefits of using protocols and extensions together is that you can create reusable code that can be applied to different types that conform to the same protocol. For example, you can create a protocol called Shape that defines a property called area and a method called draw(). Then, you can create different types of shapes, such as Circle, Square, and Triangle, that conform to the Shape protocol and implement the area and draw() methods. Finally, you can use an extension to add a new method called description() to the Shape protocol that returns a String describing the shape and its area. This way, you can use the description() method on any type that conforms to the Shape protocol without having to write it for each type separately.

4 How to declare a protocol?

To declare a protocol, you use the protocol keyword followed by the name of the protocol. Then, you list the requirements that any conforming type must implement. For example, to declare the Printable protocol, you write:

protocol Printable {
    func print() -> String
}        

5 How to conform to a protocol?

To conform to a protocol, you use the colon (:) syntax after the name of the type and list the protocols that the type conforms to. Then, you implement the requirements of the protocol in the type's body. For example, to conform to the Printable protocol, you write:

struct Person: Printable {
    var name: String
    var age: Int
    func print() -> String {
        return "Name: \(name), Age: \(age)"
    }
}        

6 How to extend a protocol?

To extend a protocol, you use the extension keyword followed by the name of the protocol. Then, you add new functionality or modify existing functionality to the protocol. For example, to extend the Printable protocol with a new method called printTwice(), you write:

extension Printable {
    func printTwice() -> String {
        return print() + "\n" + print()
    }
}        

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?