What are protocols in Swift and how to use them?

What are protocols in Swift? How to use protocols? What are protocol extensions and protocol-oriented programming?

Protocols in Swift define a blueprint of methods and properties that classes, structs, and enums can conform to implement these requirements. Protocols are an important mechanism for implementing polymorphism and code reuse in Swift.

Basic Concepts of Protocols:

• Protocols define properties, methods, and other requirements that conformers must provide
• Protocols themselves don't implement functionality, they just define interfaces
• Types can conform to multiple protocols
• Protocols can inherit from other protocols
• Protocols can be used as types

Defining Protocols:

swift
protocol FullyNamed {
    var fullName: String { get }
    func sayHello()
}

protocol Identifiable {
    var id: String { get set }
    static func generateID() -> String
}

Conforming to Protocols:

swift
struct Person: FullyNamed {
    var fullName: String
    
    func sayHello() {
        print("Hello, my name is \(fullName)")
    }
}

class Product: Identifiable {
    var id: String
    var name: String
    
    init(name: String) {
        self.id = Self.generateID()
        self.name = name
    }
    
    static func generateID() -> String {
        return UUID().uuidString
    }
}

Protocols as Types:

swift
func greet(_ person: FullyNamed) {
    print("Hello, \(person.fullName)")
    person.sayHello()
}

let john = Person(fullName: "John Doe")
greet(john)

Protocol Extensions:

• Provide default implementations for protocols
• Can add methods and properties not required by the protocol
• Can use where clause for conditional extensions
• Example:

  swift
  extension FullyNamed {
      func sayHello() {
          print("Hello, \(fullName)")
      }
      
      func introduce() {
          print("I am \(fullName)")
      }
  }
  
  extension Collection where Element: Equatable {
      func allEqual() -> Bool {
          guard let first = first else { return true }
          return all { $0 == first }
      }
  }

Protocol-Oriented Programming:

• Use protocols to define abstract interfaces
• Provide default behavior through protocol extensions
• Use protocol composition for flexible functionality
• Avoid limitations of inheritance
• Example:

  swift
  protocol Renderable {
      func render()
  }
  
  protocol Animatable {
      func animate()
  }
  
  extension Renderable {
      func render() {
          print("Rendering...")
      }
  }
  
  extension Animatable {
      func animate() {
          print("Animating...")
      }
  }
  
  struct Button: Renderable, Animatable {
      // Automatically gets default implementations
  }

Protocol Inheritance:

swift
protocol TextRepresentable {
    var textualDescription: String { get }
}

protocol PrettyTextRepresentable: TextRepresentable {
    var prettyTextualDescription: String { get }
}

Protocol Composition:

swift
protocol Named {
    var name: String { get }
}

protocol Aged {
    var age: Int { get }
}

struct Person: Named, Aged {
    var name: String
    var age: Int
}

func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}

Best Practices:

1. Use protocols to define clear interfaces
2. Provide default implementations through protocol extensions
3. Use protocol composition instead of multiple inheritance
4. Prioritize protocols over inheritance
5. Reasonably use associated types for flexibility