Mehrere Typbeschränkungen in Swift

Angenommen, ich habe diese Protokolle:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Wenn ich nun eine Funktion möchte, die einen generischen Typ annimmt, aber diesem Typ entsprechen muss, kann SomeProtocolich Folgendes tun:

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

Aber gibt es eine Möglichkeit, eine Typbeschränkung für mehrere Protokolle hinzuzufügen?

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

}

Ähnliche Dinge verwenden Kommas, aber in diesem Fall würde die Deklaration eines anderen Typs gestartet. Folgendes habe ich versucht.

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

Sie können eine where-Klausel verwenden, mit der Sie beliebig viele Anforderungen angeben können (alle müssen erfüllt sein), die durch Kommas getrennt sind

Swift 2:

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

Swift 3 & 4:

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

oder die mächtigere where-Klausel:

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

Sie können natürlich die Protokollzusammensetzung (z. B. protocol<SomeProtocol, SomeOtherProtocol>) verwenden, diese ist jedoch etwas weniger flexibel.

Mit wherekönnen Sie Fälle behandeln, in denen mehrere Typen beteiligt sind.

Möglicherweise möchten Sie weiterhin Protokolle zur Wiederverwendung an mehreren Stellen erstellen oder dem zusammengestellten Protokoll nur einen aussagekräftigen Namen geben.

Swift 5:

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

Dies fühlt sich natürlicher an, da die Protokolle neben dem Argument stehen.

Sie haben zwei Möglichkeiten:

1. Sie verwenden eine where-Klausel, wie in Jiaaros Antwort angegeben:

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

2. Sie verwenden einen Protokollzusammensetzungstyp :

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

Die Entwicklung zu Swift 3.0 bringt einige Änderungen mit sich. Unsere beiden Möglichkeiten sehen jetzt etwas anders aus.

Verwenden einer whereKlausel in Swift 3.0:

Die whereKlausel wurde jetzt an das Ende einer Funktionssignatur verschoben, um die Lesbarkeit zu verbessern. Die Vererbung mehrerer Protokolle sieht nun folgendermaßen aus:

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

}

Verwenden des protocol<>Konstrukts in Swift 3.0:

Die Zusammensetzung unter Verwendung des protocol<>Konstrukts ist veraltet. Das frühere protocol<SomeProtocol, SomeOtherProtocol>sieht jetzt so aus:

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

}

Verweise.

Weitere Informationen zu den Änderungen für wherefinden Sie hier: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

Weitere Informationen zu den Änderungen für das Protokoll <> -Konstrukt finden Sie hier: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Swift 3 bietet bis zu 3 verschiedene Möglichkeiten, Ihre Funktion zu deklarieren.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. &Operator verwenden

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

2. whereKlausel verwenden

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

3. whereKlausel und &Operator verwenden

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

Beachten Sie auch, dass Sie verwenden können typealias, um Ihre Funktionsdeklaration zu verkürzen.

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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