Generic Array of weak references to class bound protocol in Swift 4.1

Question

I'm trying to create a generic WeakReference type that I can put into an array (and ultimately create a generic weak array type).

So far so good, but the following code:

class WeakReference<ElementType: AnyObject> {
    weak var element: ElementType?

    init(_ element: ElementType) {
        self.element = element
    }
}

protocol Element: AnyObject {}

class WeakElementHolder {
    var weakElements: [WeakReference<Element>] = []
}

Produces this compiler error:

WeakReference.swift:12:21: error: 'WeakReference' requires that 'Element' be a class type
    var weakElements: [WeakReference<Element>] = []
                       ^
WeakReference.swift:1:7: note: requirement specified as 'ElementType' : 'AnyObject' [with ElementType = Element]
class WeakReference<ElementType: AnyObject> {
  ^

This is strange because the Protocol definitely requires a class (AnyObject).

Strangely everything works fine if I leave out the generics:

protocol Element: AnyObject {}

class WeakElementReference {
    weak var element: Element?

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

class WeakElementHolder {
    var weakElements: [WeakElementReference] = []
}

Searching around I found this question but it wasn't really answered.

Is there a workaround to still somehow implement a generic array of weak references that works with class bound protocols?

UPDATE:

My concrete use case is to store a list of observers that get notified when something happens:

protocol Observer: AnyObject {
    func notify()
}

class WeakReference<ElementType: AnyObject> {
    weak var element: ElementType?

    init(_ element: ElementType) {
        self.element = element
    }
}

class WeakArray<ElementType: AnyObject> {
    var content: [WeakReference<ElementType>] = []
}

class Observable {
    var observers: WeakArray<Observer>()

    func notifyAllObservers() {
        // call notify() on all observers here
    }
}

These observers can be many different concrete types.

More Clarification: There is not only one Observer protocol, there are many that have nothing in common, this is why I want this to be generic in the first place.

Martin R · Answer 1 · 2018-08-12T12:05:00.717

3

As discussed in Protocol doesn't conform to itself?, the (non-@objc) protocol defined by

protocol Element: AnyObject {}

inherits from AnyObject, but does not conform to AnyObject.

A possible solution using a type-eraser:

protocol Observer: AnyObject {
    func notify()
}

struct AnyObserver {
    weak var base: Observer?

    init(_ base: Observer ) {
        self.base = base
    }
}

class Observable {
    var observers: [AnyObserver] = []

    func add(_ observer: Observer) {
        observers.append(AnyObserver(observer))
    }

    func notifyAllObservers() {
        for observer in observers {
            observer.base?.notify()
        }
    }
}

Example usage:

class A: Observer {
    func notify() {
         print("Hello A")
    }
}

class B: Observer {
    func notify() {
        print("Hello B")
    }
}

let a = A()
let b = B()

let o = Observable()
o.add(a)
o.add(b)

o.notifyAllObservers()
// Hello A
// Hello B

edited Aug 12 '18 at 12:05

answered Aug 12 '18 at 10:08

Martin R

529,903
94
1,240
1,382

But that only pushes around the problem, since I ultimately want to have an array of protocol impelementers, not concrete types. – FSMaxB Aug 12 '18 at 10:34
The you probably need a type-eraser, as discussed in the Q&A that I linked to. – Martin R Aug 12 '18 at 10:42
But then the entire point of the generic is gone again, because I would need a type eraser for every kind of observer and a generic weak array for every one of them. – FSMaxB Aug 12 '18 at 10:58
Maybe it's just something that can't be expressed in swift. – FSMaxB Aug 12 '18 at 10:59
@FSMaxB: You need only one type eraser for the Observable protocol, not one for each conforming type. See update. – Martin R Aug 12 '18 at 12:05
but that is again not generic over different observer protocols – FSMaxB Aug 12 '18 at 12:09
@FSMaxB: I strongly assume that you need one type eraser per protocol, as indicated in the Q&A that I linked to. – Martin R Aug 12 '18 at 12:35

Generic Array of weak references to class bound protocol in Swift 4.1

1 Answers1