Restrições de tipos múltiplos no Swift

Digamos que eu tenho estes protocolos:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Agora, se eu quiser uma função que aceite um tipo genérico, mas esse tipo deva estar em conformidade, SomeProtocoleu poderia fazer:

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

Mas existe uma maneira de adicionar uma restrição de tipo para vários protocolos?

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

}

Coisas semelhantes usam vírgulas, mas, neste caso, iniciariam a declaração de um tipo diferente. Aqui está o que eu tentei.

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

Você pode usar uma cláusula where que permite especificar quantos requisitos você deseja (todos os quais devem ser atendidos) separados por vírgulas

Swift 2:

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

Swift 3 e 4:

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

ou a cláusula where mais poderosa:

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

É claro que você pode usar a composição do protocolo (por exemplo, protocol<SomeProtocol, SomeOtherProtocol>), mas é um pouco menos flexível.

Usar wherepermite lidar com casos em que vários tipos estão envolvidos.

Você ainda pode compor protocolos para reutilização em vários locais ou apenas atribuir um nome significativo ao protocolo composto.

Swift 5:

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

Isso parece mais natural, pois os protocolos estão próximos ao argumento.

Você tem duas possibilidades:

1. Você usa uma cláusula where conforme indicado na resposta de Jiaaro:

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

2. Você usa um tipo de composição de protocolo :

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

A evolução para o Swift 3.0 traz algumas mudanças. Nossas duas opções agora parecem um pouco diferentes.

Usando uma wherecláusula no Swift 3.0:

A wherecláusula agora foi movida para o final de uma assinatura de função para melhorar a legibilidade. Portanto, a herança de vários protocolos agora se parece com isso:

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

}

Usando a protocol<>construção no Swift 3.0:

A composição usando a protocol<>construção está sendo preterida. O anterior protocol<SomeProtocol, SomeOtherProtocol>agora se parece com isso:

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

}

Referências.

Mais informações sobre as alterações whereestão aqui: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

E, mais sobre as mudanças para a construção do protocolo <> estão aqui: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

O Swift 3 oferece até três maneiras diferentes de declarar sua função.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. Usando &operador

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

2. whereCláusula Using

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

3. Usando wherecláusula e &operador

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

Observe também que você pode usar typealiaspara reduzir sua declaração de função.

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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