Contraintes de type multiple dans Swift

Disons que j'ai ces protocoles:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Maintenant, si je veux une fonction qui prend un type générique, mais que ce type doit être conforme, SomeProtocolje pourrais faire:

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

Mais existe-t-il un moyen d'ajouter une contrainte de type pour plusieurs protocoles?

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

}

Des choses similaires utilisent des virgules, mais dans ce cas, cela commencerait la déclaration d'un type différent. Voici ce que j'ai essayé.

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

Vous pouvez utiliser une clause where qui vous permet de spécifier autant d'exigences que vous le souhaitez (qui doivent toutes être remplies) séparées par des virgules

Swift 2:

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

Swift 3 et 4:

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

ou la clause where la plus puissante:

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

Vous pouvez bien sûr utiliser la composition de protocole (par exemple, protocol<SomeProtocol, SomeOtherProtocol>), mais c'est un peu moins flexible.

L'utilisation wherevous permet de traiter les cas où plusieurs types sont impliqués.

Vous voudrez peut-être toujours composer des protocoles pour les réutiliser à plusieurs endroits, ou simplement donner au protocole composé un nom significatif.

Swift 5:

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

Cela semble plus naturel car les protocoles sont à côté de l'argument.

Vous avez deux possibilités:

1. Vous utilisez une clause where comme indiqué dans la réponse de Jiaaro:

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

2. Vous utilisez un type de composition de protocole :

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

L'évolution vers Swift 3.0 apporte quelques changements. Nos deux choix sont maintenant un peu différents.

Utilisation d'une whereclause dans Swift 3.0:

La whereclause est maintenant déplacée à la fin d'une signature de fonction pour améliorer la lisibilité. L'héritage de plusieurs protocoles ressemble maintenant à ceci:

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

}

Utilisation de la protocol<>construction dans Swift 3.0:

La composition utilisant la protocol<>construction est obsolète. Le plus tôt protocol<SomeProtocol, SomeOtherProtocol>ressemble maintenant à ceci:

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

}

Références.

Plus d'informations sur les changements pour wheresont ici: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

Et, plus sur les changements pour la construction de protocole <> sont ici: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Swift 3 propose jusqu'à 3 façons différentes de déclarer votre fonction.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. Utilisation de l' &opérateur

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

2. Utilisation de la whereclause

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

3. Utilisation de la whereclause et de l' &opérateur

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

Notez également que vous pouvez utiliser typealiaspour raccourcir votre déclaration de fonction.

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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