Vincoli di tipo multiplo in Swift

Diciamo che ho questi protocolli:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Ora, se voglio una funzione che accetta un tipo generico, ma a quel tipo deve essere conforme, SomeProtocolpotrei fare:

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

Ma c'è un modo per aggiungere un vincolo di tipo per più protocolli?

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

}

Cose simili usano le virgole, ma in questo caso, inizierebbe la dichiarazione di un tipo diverso. Ecco cosa ho provato.

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

È possibile utilizzare una clausola where che consente di specificare tutti i requisiti desiderati (che devono essere soddisfatti tutti) separati da virgole

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
}

o la clausola where più potente:

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

Ovviamente puoi usare la composizione del protocollo (ad es. protocol<SomeProtocol, SomeOtherProtocol>), Ma è un po 'meno flessibile.

L'utilizzo whereconsente di gestire i casi in cui sono coinvolti più tipi.

Potresti comunque voler comporre protocolli per il riutilizzo in più posizioni o semplicemente dare un nome significativo al protocollo composto.

Swift 5:

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

Ciò sembra più naturale poiché i protocolli sono accanto all'argomento.

Hai due possibilità:

1. Usi una clausola where come indicato nella risposta di Jiaaro:

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

2. Si utilizza un tipo di composizione protocollo :

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

L'evoluzione in Swift 3.0 porta alcuni cambiamenti. Le nostre due scelte ora sembrano leggermente diverse.

Utilizzando una whereclausola in Swift 3.0:

La whereclausola è ora spostata alla fine della firma di una funzione per migliorare la leggibilità. Quindi l'ereditarietà di più protocolli ora appare così:

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

}

Utilizzando il protocol<>costrutto in Swift 3.0:

La composizione che utilizza il protocol<>costrutto è obsoleta. Il precedente protocol<SomeProtocol, SomeOtherProtocol>ora appare così:

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

}

Riferimenti.

Maggiori informazioni sulle modifiche per wheresono disponibili qui: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

E ulteriori informazioni sulle modifiche per il protocollo <> sono disponibili qui: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Swift 3 offre fino a 3 modi diversi per dichiarare la tua funzione.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. Utilizzo &dell'operatore

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

2. Utilizzo della whereclausola

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

3. Utilizzo della whereclausola e &dell'operatore

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

Si noti inoltre che è possibile utilizzare typealiasper abbreviare la dichiarazione delle funzioni.

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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