Swift中的多个类型约束

假设我有以下协议：

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>

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

斯威夫特2：

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

Swift 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
}

由于协议离论点很近，因此感觉更自然。

您有两种可能性：

1. 如Jiaaro的答案所示，您使用where子句：

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

2. 您使用协议组成类型：

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

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

where在Swift 3.0中使用子句：

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

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

}

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

使用该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

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

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1.使用&运算符

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

2. using where子句

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

3. using where子句和&运算符

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

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

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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