Обмеження декількох типів у Swift

Скажімо, у мене є такі протоколи:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Тепер, якщо я хочу функцію, яка приймає загальний тип, але цей тип повинен відповідати, SomeProtocolя можу зробити:

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

Але чи є спосіб додати обмеження типу для декількох протоколів?

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

}

У подібних речах використовуються коми, але в цьому випадку воно розпочнеть декларацію іншого типу. Ось що я спробував.

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

Ви можете використовувати пункт де, який дозволяє вказати стільки вимог, скільки потрібно (усі вони повинні бути виконані), розділених комами

Швидкий 2:

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

Swift 3 і 4:

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

або найпотужніший де пункт:

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

Можна, звичайно, використовувати склад протоколу (наприклад, protocol<SomeProtocol, SomeOtherProtocol>), але це трохи менш гнучко.

Використання whereдозволяє вирішувати випадки, коли задіяно кілька типів.

Ви все ще можете скласти протоколи для повторного використання в декількох місцях або просто дати складеному протоколу значущу назву.

Швидкий 5:

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

Це здається більш природним, оскільки протоколи поряд з аргументом.

У вас є дві можливості:

1. Ви використовуєте пункт де, як зазначено у відповіді Цзяаро:

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

2. Ви використовуєте тип композиції протоколу :

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

Еволюція до Swift 3.0 приносить деякі зміни. Наші два варіанти виглядають дещо інакше.

Використання whereпункту в Swift 3.0:

Розділ whereтепер переміщено до кінця підпису функції для поліпшення читабельності. Тож багаторазове успадкування протоколу зараз виглядає так:

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

}

Використання protocol<>конструкції в Swift 3.0:

Композиція з використанням protocol<>конструкції застаріла. Раніше protocol<SomeProtocol, SomeOtherProtocol>зараз виглядає так:

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

}

Список літератури.

Більше інформації про зміни можна whereзнайти тут: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

Більше про зміни для протоколу <> construct читайте тут: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Swift 3 пропонує до 3 різних способів заявити про свою функцію.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. Використання &оператора

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

2. Використання whereпункту

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

3. Використання whereпункту та &оператора

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

Також зауважте, що ви можете використовувати їх typealiasдля скорочення декларації функції.

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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