swift – 通用类型集合

如果我们将其归结为最小的测试用例,这可能会更清楚一些

protocol Creatable { init() }

struct Object : Creatable { init() {} }

func instantiate<T: Creatable>(Thing: T.TypE) -> T {
    return Thing()
}

// works. object is of type "Object"
let object = instantiate(Object.self)   // (1)

// 'Creatable.Type' is not convertible to 'T.Type'
let type: Creatable.Type = Object.self
let thing = instantiate(typE)  // (2)

在第1行,编译器有一个问题：在这个实例化实例中T应该是什么类型？这很容易,它应该是对象.这是一个具体的类型,所以一切都很好.

在第2行,没有Swift可以制作的具体类型T.它只有Creatable,这是一个抽象类型(我们通过代码检查知道类型的实际值,但Swift不考虑值,只是类型) .获取和返回协议是可以的,但是将它们变成类型参数是不可行的.今天,斯威夫特不合法.

这在Swift Programming Language: Generic Parameters and Arguments中暗示：

你需要做任何你想在Swift中做另一种方式的事情.

作为一个有趣的奖金,尝试明确要求不可能：

let thing = instantiate(Creatable.self)

并且…迅速崩溃.

从您的进一步评论中,我认为闭包完全符合您的要求.你已经使你的协议需要简单的构造(init()),但这是一个不必要的限制.您只需要调用者告诉函数如何构造对象.使用闭包很容易,并且不需要以这种方式进行类型参数化.这不是一个解决方法;我相信这是实现您所描述的模式的更好方法.请考虑以下内容(一些小的更改,使示例更像Swift)：

// Removed init(). There's no need for it to be trivially creatable.
// Cocoa protocols that inDicate a method generally end in "ing" 
// (NSCopying,NSCoding,NSLocking). They do not include "I"
public protocol Speaking {
    func speak()
}

// Converted these to structs since that's all that's required for
// this example,but it works as well for classes.
struct Cat : Speaking {
    func speak() {
        println("Meow");
    }
}

struct Dog : Speaking {
    func speak() {
        println("Woof");
    }
}

// Demonstrating a more complex object that is easy with closures,// but hard with your original protocol
struct Person: Speaking {
    let name: String
    func speak() {
        println("My name is \(Name)")
    }
}

// Removed Test class. There was no need for it in the example,// but it works fine if you add it.
// You pass a closure that returns a Speaking. We don't care *how* it does
// that. It doesn't have to be by construction. It Could return an exisTing one.
func instantiateAndCallSpeak(builder: () -> Speaking) {
    let animal = builder()
    animal.speak()
}

// Can call with an immediate form.
// Note that Cat and Dog are not created here. They are not created until builder()
// is called above. @autoclosure would avoid the braces,but I typically avoid it.
instantiateAndCallSpeak { Cat() }
instantiateAndCallSpeak { Dog() }

// Can put them in an array,though we do have to specify the type here. You Could
// create a "typealias SpeakingBuilder = () -> Speaking" if that came up a lot.
// Again note that no Speaking objects are created here. these are closures that
// will generate objects when applied.
// Notice how easy it is to pass parameters here? these don't all have to have the
// same initializers.
let animalBuilders: [() -> Speaking] = [{ Cat() },{ Dog() },{ Person(name: "Rob") }]

for animal in animalBuilders {
    instantiateAndCallSpeak(animal)
}