Swift Language Protocol Basics

Download Swift Language for free


About Protocols

A Protocol specifies initialisers, properties, functions, subscripts and associated types required of a Swift object type (class, struct or enum) conforming to the protocol. In some languages similar ideas for requirement specifications of subsequent objects are known as ‘interfaces’.

A declared and defined Protocol is a Type, in and of itself, with a signature of its stated requirements, somewhat similar to the manner in which Swift Functions are a Type based on their signature of parameters and returns.

Swift Protocol specifications can be optional, explicitly required and/or given default implementations via a facility known as Protocol Extensions. A Swift Object Type (class, struct or enum) desiring to conform to a Protocol that’s fleshed out with Extensions for all its specified requirements needs only state its desire to conform to be in full conformance. The default implementations facility of Protocol Extensions can suffice to fulfil all obligations of conforming to a Protocol.

Protocols can be inherited by other Protocols. This, in conjunction with Protocol Extensions, means Protocols can and should be thought of as a significant feature of Swift.

Protocols and Extensions are important to realising Swift’s broader objectives and approaches to program design flexibility and development processes. The primary stated purpose of Swift’s Protocol and Extension capability is facilitation of compositional design in program architecture and development. This is referred to as Protocol Oriented Programming. Crusty old timers consider this superior to a focus on OOP design.

Protocols define interfaces which can be implemented by any struct, class, or enum:

protocol MyProtocol {
    init(value: Int)                      // required initializer
    func doSomething() -> Bool            // instance method
    var message: String { get }           // instance read-only property
    var value: Int { get set }            // read-write instance property
    subscript(index: Int) -> Int { get }  // instance subscript
    static func instructions() -> String  // static method
    static var max: Int { get }           // static read-only property
    static var total: Int { get set }     // read-write static property

Properties defined in protocols must either be annotated as { get } or { get set }. { get } means that the property must be gettable, and therefore it can be implemented as any kind of property. { get set } means that the property must be settable as well as gettable.

A struct, class, or enum may conform to a protocol:

struct MyStruct : MyProtocol {
    // Implement the protocol's requirements here
class MyClass : MyProtocol {
    // Implement the protocol's requirements here
enum MyEnum : MyProtocol {
    case caseA, caseB, caseC
    // Implement the protocol's requirements here

A protocol may also define a default implementation for any of its requirements through an extension:

extension MyProtocol {
    // default implementation of doSomething() -> Bool
    // conforming types will use this implementation if they don't define their own
    func doSomething() -> Bool {
        print("do something!")
        return true

A protocol can be used as a type, provided it doesn't have associatedtype requirements:

func doStuff(object: MyProtocol) {
    // All of MyProtocol's requirements are available on the object

let items : [MyProtocol] = [MyStruct(), MyClass(), MyEnum.caseA]

You may also define an abstract type that conforms to multiple protocols:


With Swift 3 or better, this is done by separating the list of protocols with an ampersand (&):

func doStuff(object: MyProtocol & AnotherProtocol) {
    // ...

let items : [MyProtocol & AnotherProtocol] = [MyStruct(), MyClass(), MyEnum.caseA]

Older versions have syntax protocol<...> where the protocols are a comma-separated list between the angle brackets <>.

protocol AnotherProtocol {
    func doSomethingElse()

func doStuff(object: protocol<MyProtocol, AnotherProtocol>) {
    // All of MyProtocol & AnotherProtocol's requirements are available on the object

// MyStruct, MyClass & MyEnum must now conform to both MyProtocol & AnotherProtocol
let items : [protocol<MyProtocol, AnotherProtocol>] = [MyStruct(), MyClass(), MyEnum.caseA]

Existing types can be extended to conform to a protocol:

extension String : MyProtocol {
    // Implement any requirements which String doesn't already satisfy
Associated type requirements