Swift Protocols Cheat Sheet

protocol Vehicle {    var wheels: Int { get }    func drive() -> String}struct Car: Vehicle {    var wheels: Int = 4    func drive() -> String {        "Driving a car with \(wheels) wheels"    }}struct Motorcycle: Vehicle {    var wheels: Int = 2    func drive() -> String {        "Riding a motorcycle"    }}let vehicles: [Vehicle] = [Car(), Motorcycle()]for v in vehicles {    print(v.drive())}

protocol Greetable {    var name: String { get }}// Default implementation shared by every conforming typeextension Greetable {    func greet() -> String {        "Hello, \(name)!"    }}struct Person: Greetable {    var name: String    // greet() comes free from the extension}struct Robot: Greetable {    var name: String    // Override the default implementation    func greet() -> String {        "BEEP BOOP, \(name)"    }}print(Person(name: "Ana").greet()) // "Hello, Ana!"print(Robot(name: "R2").greet())   // "BEEP BOOP, R2"

protocol Container {    associatedtype Item    var items: [Item] { get set }    mutating func add(_ item: Item)}struct Stack<T>: Container {    var items: [T] = []    mutating func add(_ item: T) {        items.append(item)    }}var intStack = Stack<Int>()intStack.add(1)intStack.add(2)// Protocols with associated types can't be used as a plain type// (`Container` alone) -- use `some Container` or generics instead.func printCount(_ container: some Container) {    print(container.items.count)}

protocol Shape {    func area() -> Double}struct Circle: Shape {    var radius: Double    func area() -> Double { .pi * radius * radius }}// `any Shape` is an existential container: a fixed-size inline buffer// (3 words) plus a pointer to a protocol witness table. Values larger// than the inline buffer are heap-allocated and boxed.let shapes: [any Shape] = [Circle(radius: 2)]// Generic functions specialize per concrete type at compile time --// no boxing, no dynamic dispatch through a witness table.func totalArea<S: Shape>(_ shapes: [S]) -> Double {    shapes.reduce(0) { $0 + $1.area() }}// Mixed collections force existentials; homogeneous ones can stay generic.func totalAreaBoxed(_ shapes: [any Shape]) -> Double {    shapes.reduce(0) { $0 + $1.area() }}

struct Box<Content> {    var contents: Content}// Box<Content> is only Equatable when Content itself is Equatableextension Box: Equatable where Content: Equatable {    static func == (lhs: Box, rhs: Box) -> Bool {        lhs.contents == rhs.contents    }}// Same technique underlies Array's `Equatable` conformance in the// standard library: `extension Array: Equatable where Element: Equatable`let a = Box(contents: 1)let b = Box(contents: 1)print(a == b) // true, only compiles because Int: Equatable

protocol Trackable {    func log()}extension Trackable {    func log() { print("Trackable.log") }    // NOT in the protocol requirement list -- resolved statically    func extra() { print("Trackable.extra") }}struct Event: Trackable {    func log() { print("Event.log") }        // overrides via dynamic dispatch    func extra() { print("Event.extra") }    // shadows, but NOT overridden dynamically}let event = Event()let trackable: Trackable = eventtrackable.log()   // "Event.log"   -- log() is a protocol requirement, dispatched dynamicallytrackable.extra() // "Trackable.extra" -- extra() isn't a requirement, resolved at compile time by static type

protocol Repository<Model> {    associatedtype Model    func fetchAll() -> [Model]}struct UserRepository: Repository {    func fetchAll() -> [String] { ["alice", "bob"] }}// Primary associated type lets you constrain the placeholder directly,// instead of a separate `where` clausefunc printAll(_ repo: some Repository<String>) {    repo.fetchAll().forEach { print($0) }}// Also usable with `any`:func handle(_ repo: any Repository<String>) {    print(repo.fetchAll().count)}