Working with Extensions for Protocol Conformance

In Swift, extensions allow you to add new functionality to existing types. They can also be used to make a type conform to a protocol. By extending a type and implementing the requirements of a protocol, you can make that type adhere to the protocol's contract without modifying its original implementation. This is particularly useful when working with types you don't have direct control over, such as built-in types or third-party libraries.

Let's say you have a protocol called Drawable, which defines a single method draw().

protocol Drawable {
    func draw()
}

Now, suppose you have a custom class called Rectangle, and you want it to conform to the Drawable protocol. You can do this using an extension:

class Rectangle {
    var width: Double
    var height: Double
    
    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
}

extension Rectangle: Drawable {
    func draw() {
        print("Drawing a rectangle with width: \(width) and height: \(height)")
    }
}

In the code above, we extend the Rectangle class and provide an implementation for the Drawable protocol's draw() method. Now, instances of the Rectangle class can be treated as Drawable objects and called to draw themselves.

let rectangle = Rectangle(width: 10, height: 5)
rectangle.draw() // Output: Drawing a rectangle with width: 10.0 and height: 5.0}

Extensions for protocol conformance can also be used with value types like structs and enums. You can even extend protocols themselves to provide default implementations for their requirements. Extensions provide a powerful mechanism for adding capabilities to existing types without modifying or subclassing them. Whether you are working with your own types or types from external sources, extensions allow you to retrofit them with additional functionality and make them adhere to protocols.