Swift 中的多种类型约束

Question

假设我有这些协议：

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

现在，如果我想要一个采用泛型类型的函数，但该类型必须符合 SomeProtocol，我可以这样做：

func someFunc<T: SomeProtocol>(arg: T) {
    // do stuff
}

但是有没有办法为多个协议添加类型约束？

func bothFunc<T: SomeProtocol | SomeOtherProtocol>(arg: T) {

}

类似的东西使用逗号，但在这种情况下，它会开始声明不同的类型。这是我尝试过的。

<T: SomeProtocol | SomeOtherProtocol>
<T: SomeProtocol , SomeOtherProtocol>
<T: SomeProtocol : SomeOtherProtocol>

Answer 1

您可以使用where clause，它允许您指定任意数量的要求（必须满足所有要求），用逗号分隔

斯威夫特 2：

func someFunc<T where T:SomeProtocol, T:SomeOtherProtocol>(arg: T) {
    // stuff
}

斯威夫特 3 和 4：

func someFunc<T: SomeProtocol & SomeOtherProtocol>(arg: T) {
    // stuff
}

或更强大的where子句：

func someFunc<T>(arg: T) where T:SomeProtocol, T:SomeOtherProtocol{
    // stuff
}

您当然可以使用协议组合（例如，protocol<SomeProtocol, SomeOtherProtocol>），但灵活性稍差。

使用where 可以处理涉及多种类型的情况。

您可能仍想组合协议以便在多个地方重用，或者只是为组合的协议起一个有意义的名称。

斯威夫特 5：

func someFunc(arg: SomeProtocol & SomeOtherProtocol) { 
    // stuff
}

这感觉更自然，因为协议在参数旁边。

Answer 2

你有两种可能：

1. 您使用 where clause，如 Jiaaro 的回答所示：

   func someFunc<T where T : SomeProtocol, T : SomeOtherProtocol>(arg: T) {
       // do stuff
   }
   

2. 您使用 protocol composition type：

   func someFunc<T : protocol<SomeProtocol, SomeOtherProtocol>>(arg: T) {
       // do stuff
   }
   

Answer 3

向 Swift 3.0 的演进带来了一些变化。我们的两个选择现在看起来有些不同了。

在 Swift 3.0 中使用 where 子句：

where 子句现已移至函数签名的末尾以提高可读性。所以多协议继承现在看起来像这样：

func someFunc<T>(arg: T) where T:SomeProtocol, T:SomeOtherProtocol {

}

在 Swift 3.0 中使用 protocol<> 构造：

使用protocol<> 构造的组合已被弃用。之前的 protocol<SomeProtocol, SomeOtherProtocol> 现在看起来像这样：

func someFunc<T:SomeProtocol & SomeOtherProtocol>(arg: T) {

}

参考资料。

有关where 更改的更多信息在这里：https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

而且，关于协议 结构的更多变化在这里：https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Answer 4

Swift 3 提供多达 3 种不同的方式来声明您的函数。

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1。使用& 运算符

func someFunc<T: SomeProtocol & SomeOtherProtocol>(arg: T) {
    /* ... */
}

2。使用where 子句

func someFunc<T>(arg: T) where T: SomeProtocol, T: SomeOtherProtocol {
    /* ... */
}

3。使用where 子句和& 运算符

func someFunc<T>(arg: T) where T: SomeProtocol & SomeOtherProtocol {
    /* ... */        
}

---

还请注意，您可以使用typealias 来缩短您的函数声明。

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

func someFunc<T: RequiredProtocols>(arg: T) {
    /* ... */   
}