Protocols and Generics

A protocol is a contract of requirements with no stored state of its own. Unlike a base class it allows many conformances and fits structs and enums, not just classes. Protocol-oriented programming composes small protocols with default extensions.

An extension can add computed properties, methods, initializers, subscripts, nested types, and protocol conformances to a type. It cannot add a stored property, because that changes the type's memory layout, fixed at the original declaration.

Codable unlocks JSON encoding and decoding, Equatable enables ==, Hashable lets a type be a Set element or dictionary key, Identifiable gives SwiftUI a stable id for lists, and CustomStringConvertible sets its description in logs.

A conditional conformance makes a generic type conform only when its parameter does — extension Array: Summable where Element: Summable. It unlocks the API for [Int] but not [UIView], as [T] becomes Equatable exactly when its T is.

Swift synthesizes Equatable/Hashable when every stored property conforms and you declare it in the type's file. Write them by hand when equality should ignore fields — compare only id in == and feed just id to hash(into:).

A declared requirement runs the type's own override through both any P and some P — the witness table picks it, and the default fills in only when the type adds none. A method living only in the extension is static; its default always wins.

some P is an opaque type — one concrete type the compiler knows, so calls stay static and unboxed. any P is an existential box holding any conforming type, dispatched dynamically via the witness table. Reach for any when the type must vary.

func mostFrequent<T: Hashable>(_ xs: [T]) -> T? — the Hashable bound lets T be a dictionary key to tally counts, and T? is returned because empty input has no mode. A where clause adds constraints like T: Comparable to break ties.

An associated type is fixed by the conformer — one per conformance, not chosen by the caller. A generic parameter is picked by the caller at each use. Use an associated type for a type intrinsic to the conformer, a generic when the caller decides.

Whole-module optimization sees every call site at once, so it can prove a method is never overridden and make a vtable or witness call direct. final and private state that locally, letting generic specialization inline the concrete type.

Direct (static) dispatch inlines the call for final, private, static, and struct methods. Non-final class methods use a vtable; protocol requirements via generics or existentials use a witness table; @objc dynamic members use objc_msgSend.

[any Shape] wraps each element in an existential container and dispatches calls via the witness table, unspecialized. [T] where T: Shape is one concrete type the optimizer specializes and inlines, so calls stay static, elements unboxed.

An associated type gives a protocol no single concrete type, so before Swift 5.7 it worked only as a generic constraint, not an existential. Swift 5.7 allowed the existential and added primary associated types to pin one — any Collection<Int>.