Restricciones de tipo múltiple en Swift

Digamos que tengo estos protocolos:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Ahora, si quiero una función que tome un tipo genérico, pero ese tipo debe cumplir SomeProtocol, podría hacer:

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

Pero, ¿hay alguna manera de agregar una restricción de tipo para múltiples protocolos?

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

}

Cosas similares usan comas, pero en este caso, comenzaría la declaración de un tipo diferente. Esto es lo que he intentado.

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

Puede usar una cláusula where que le permite especificar tantos requisitos como desee (todos los cuales deben cumplirse) separados por comas

Swift 2:

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

Swift 3 y 4:

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

o la cláusula where más poderosa:

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

Por supuesto, puede usar la composición del protocolo (por ejemplo, protocol<SomeProtocol, SomeOtherProtocol>), pero es un poco menos flexible.

El uso le wherepermite tratar casos en los que intervienen varios tipos.

Es posible que aún desee componer protocolos para su reutilización en varios lugares, o simplemente para dar al protocolo compuesto un nombre significativo.

Swift 5:

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

Esto se siente más natural ya que los protocolos están al lado del argumento.

Tienes dos posibilidades:

1. Utiliza una cláusula where como se indica en la respuesta de Jiaaro:

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

2. Utiliza un tipo de composición de protocolo :

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

La evolución a Swift 3.0 trae algunos cambios. Nuestras dos opciones ahora se ven un poco diferentes.

Usando una wherecláusula en Swift 3.0:

La wherecláusula ahora se ha movido al final de una firma de función para mejorar la legibilidad. Entonces, la herencia de múltiples protocolos ahora se ve así:

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

}

Usando la protocol<>construcción en Swift 3.0:

La composición que usa la protocol<>construcción está en desuso. Lo anterior protocol<SomeProtocol, SomeOtherProtocol>ahora se ve así:

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

}

Referencias

Aquí encontrará más información sobre los cambios where: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

Y, más sobre los cambios para la construcción del protocolo <> están aquí: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Swift 3 ofrece hasta 3 formas diferentes de declarar su función.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. Usando &operador

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

2. Usando la wherecláusula

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

3. Usando wherecláusula y &operador

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

También tenga en cuenta que puede usar typealiaspara acortar su declaración de función.

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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