It may happen that two objects reference each other, so one of them needs to weakly reference the order in order to avoid memory leaks. I would like to show you my approach to defining such requirements at the protocol level.

Weak references

In Swift when there are two objects that both might reference each other through their properties one would typically mark one of them with the weak keyword. The keyword is related to the Swift memory model ARC and means that this reference won’t be keeping the object alive in case nothing more would point to it. Thanks to this there will be no reference cycles, thus so no memory leaks.

Day to day use case in iOS development for such properties is the delegation pattern. An object that wants to pass some information to its delegate would mark the property as weak. It happens often that the object is being directly stored by its delegate, so that helps to avoid reference cycles.

Weak properties in protocols

Up until Swift 4.1 (Xcode 9.3) it seemed to be legitimately possible to use the weak keyword for properties defined in protocols. Since version 4.1 the compiler warns about such usage and informs, that it will be disallowed in future versions.

1
2
3
4
5
6
7

protocol MyDelegate: class { }
 
protocol MyProtocol {

  weak var prop: MyDelegate? { get set  }
}

Compiling such code results in the following message:

warning: ‘weak’ should not be applied to a property declaration in a protocol and will be disallowed in future versions

There’s a very good reason to disallow such definition at the protocol level and that is because compiler doesn’t actually enforce the types that implement it to use the keyword. In previous versions that could have led to memory leaks if one would forget about adding the weak keyword.

How to enforce weak references in protocol properties

A possible solution to enforcing weak references in protocols could be to define a type that wraps it, similarly to the Unmanaged type defined in language standard library.

Such type could be defined as:

1
2
3
4
5
6
7
8

class WeakRef<Element: AnyObject> {

    weak private(set) var pointee: Element?

    init(_ pointee: Element) {
        self.pointee = pointee
    }
}

The reference property can be accessed at any time and the WeakRef type can be used any other with protocols.

Now we should be able to define our delegate property using the WeakRef type, right?

1
2
3
4

protocol MyProtocol {

  weak var prop: WeakRef<MyDelegate>? { get set }
}

Unfortunately, this does not compile, and we get following error:

error: ‘WeakRef’ requires that ‘MyDelegate’ be a class type

This is due to so-called existentsials in Swift, as they do not directly match the requirements of being a class bound.

There’s a possibility to workaround this by changing type definition to be slightly less constraining, like that:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class WeakRef<Element> {

    weak private var value: AnyObject?

    var pointee: Element? {
        return value as? Element
    }

    init<T: AnyObject>(_ pointee: T) {
        self.value = pointee
    }
}

There’re some downsides to such solution, as its still not possible to directly initialise the reference using existential protocol storage and there’s typecasting involved. It will be probably sufficient in most cases though normally one would assign the delegate like myProtocol.delegate = WeakRef(self) and that would work!

Thanks for reading! If you’ve got any questions, comments, or general feedback, you can find all my social links at the bottom of the page.