Swift：使用通配符作为泛型类型参数

Question

我想在字典中存储从泛型类型派生的类的实例；也就是说，字典应该存储从这个泛型派生的 any 类的一个实例。

类似这样的：

class ParentClass {}
class ChildClass: ParentClass {}

class GenericClass<T: ParentClass> {
    var foo:T?
}

typealias DerivedClass = GenericClass<ChildClass>

class TestGenerics {

    var dict: Dictionary<String, GenericClass<**what goes here??**>> = [:]

    func test() {
        var derivedClassInstance = DerivedClass()
        dict.updateValue(derivedClassInstance, forKey: "name")
    }
}

这在 Java 中相当简单：

public class TestGenericsOuter {

    class ParentClass {}
    class ChildClass extends ParentClass {}

    class GenericClass<T extends ParentClass> {
        T foo;
    }

    class DerivedClass extends GenericClass<ChildClass> {}

    class TestGenerics {

        Dictionary<String, GenericClass<? extends ParentClass>> dict;

        void test() {
            DerivedClass derivedClassInstance = new DerivedClass();
            dict.put("name", derivedClassInstance);

        }
    }

}

这样的事情在 Swift 中是否可行？我让它工作的唯一方法是创建一个以“Any”作为值类型的字典。但是，我失去了一些类型安全性，所以我想尽可能避免这种解决方案。

Answer 1

我认为您不能模仿 Java 的通配符，但您可能也不需要这样做。您可以在代码需要ParentClass 的任何地方使用ChildClass。所以用你的例子：

class TestGenerics {
    var dict: Dictionary<String, GenericClass<ParentClass>> = [:]

    func test() {
        var derivedClassInstance = GenericClass<ParentClass>()
        dict.updateValue(derivedClassInstance, forKey: "name")
    }
}

现在只需使用ChildClass 填写foo

let test = TestGenerics()
test.test()
test.dict["name"]?.foo = ChildClass()

该代码编译时没有错误。但是，Swift 不支持自定义泛型类的协变，因此您无法使用协变类型更改字典，因此以下内容无法编译：

test.dict = Dictionary<String, GenericClass<ChildClass>>()
//Error: 'ChildClass' is not identical to 'ParentClass'

这不是很直观，因为原生数组和字典确实支持协方差，所以这是允许的：

let array: Array<ParentClass> = Array<ChildClass>()
let dic: Dictionary<String, ParentClass> = Dictionary<String, ChildClass>()

但不是这个：

let generic: GenericClass<ParentClass> = GenericClass<ChildClass>()
//Error: 'ChildClass' is not identical to 'ParentClass'

基本上，Swift 将Array<ChildClass> 视为Array<ParentClass> 的子类型，但目前无法告诉编译器GenericClass<ChildClass> 是（或应该是）GenericClass<ParentClass> 的子类型。希望随着语言的发展，将添加一种将自定义类声明为协变的方法。

Answer 2

您需要参数化包含要被设为通用的任何引用的类型，并在那里使用类型约束。此外，typealias 与参数化类型的约束有关，因此它位于该类型内部。

class ParentClass {}
class ChildClass: ParentClass {}

class GenericClass<T: ParentClass> {
    var foo:T?
}


class TestGenerics<T: ParentClass> {
    typealias DerivedClass = GenericClass<T>

    var dict: Dictionary<String, GenericClass<T>> = [:]

    func test() {
        var derivedClassInstance = DerivedClass()
        dict.updateValue(derivedClassInstance, forKey: "name")
    }
}

let blah = TestGenerics<ChildClass>()
let baz = GenericClass<ChildClass>()
baz.foo = ChildClass()
blah.dict = ["a":baz]