swift - 将通用结构与协议(protocol)一起使用

Question

似乎 Swift 泛型工作正常，只要我不尝试以任何实际方式组合它们。我正在使用 Swift 4.1，我想创建一个仅包含弱引用的通用数组。我可以将其定义为 WeakList<T> .到目前为止一切顺利。但是:我想为 T 使用协议(protocol). swift 说不..

import Foundation

protocol Observer: class {
    func stateChanged(sender: SomeClass, newState: Int)
}

struct WeakList<T> where T: AnyObject {
    struct Ptr {
        weak var p: T?
    }
    private var storage: [Ptr] = []
    var aliveObjects: [T] {
        var result: [T] = []
        for ptr in storage {
            if let p = ptr.p {
                result.append(p)
            }
        }
        return result
    }
    mutating func add(_ obj: T) {
        storage.append(Ptr(p: obj))
    }
    // Let's ignore for a moment that this implementation leaks memory badly.
}

class SomeClass {
    var someVar: WeakList<Observer> = WeakList<Observer>()
    // Error: WeakList requires that 'Observer' be a class type

    var thisIsOk: WeakList<NSObject> = WeakList<NSObject>()
}

(这不是我的原始代码，而是一个包含足够细节的最小可验证示例，因此没有人可以说“只需从结构中删除 AnyObject 约束”)

我想我想做的是不可能的。或者是吗？令人沮丧的是，当我尝试使用 Swift 泛型做某事时，有 5 次中有 4 次，我后来才知道我正在尝试做的事情是不可能的。 (顺便说一句，我可以很容易地在 Objective-C 中实现同样的事情。)

• 我尝试更改 class对 AnyObject 的约束约束 => 也不起作用。
  
• 我试图改变 AnyObject对 class 的约束约束 => 甚至无法编译。
  
• 并将其更改为 protocol Observer where Self: NSObject没有改变任何东西。 NSObject是一个类类型，Observer是一个 NSObject .它应该遵循 Observer是一个类类型。 "is"关系在这里似乎不具有传递性。

Answer 1

在当前的实现中，您无法从 AnyObject 继承协议(protocol)。你可以做的是为你的协议(protocol)创建一个类型橡皮擦，然后使用它。现在您的类型橡皮擦可以从 AnyObject 继承。

像这样:

protocol Observer {
    func stateChanged(sender: SomeClass, newState: Int)
}

class AnyObserver: NSObject, Observer {
    private let observer: Observer

    init(observer: Observer) {
        self.observer = observer
    }

    func stateChanged(sender: SomeClass, newState: Int) {
        observer.stateChanged(sender: sender, newState: newState)
    }
}

struct WeakList<T> where T: AnyObject {
    struct Ptr {
        weak var p: T?
    }
    private var storage: [Ptr] = []
    var aliveObjects: [T] {
        var result: [T] = []
        for ptr in storage {
            if let p = ptr.p {
                result.append(p)
            }
        }
        return result
    }
    mutating func add(_ obj: T) {
        storage.append(Ptr(p: obj))
    }
    // Let's ignore for a moment that this implementation leaks memory badly.
}

class SomeClass {
    var someVar: WeakList<AnyObserver> = WeakList<AnyObserver>()

    var thisIsOk: WeakList<NSObject> = WeakList<NSObject>()
}