Swift'de Çoklu Tip Kısıtlamaları

Diyelim ki şu protokollere sahibim:

protocol SomeProtocol {

}

protocol SomeOtherProtocol {

}

Şimdi, genel bir tür alan bir işlev istiyorsam, ancak bu türün uyması gerekiyorsa SomeProtocolyapabilirim:

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

Ancak birden çok protokol için tür kısıtlaması eklemenin bir yolu var mı?

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

}

Benzer şeyler virgül kullanır, ancak bu durumda farklı bir tür beyanı başlatır. İşte denediğim şey.

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

Virgülle ayırarak istediğiniz kadar çok gereksinimi (tümü yerine getirilmelidir) belirtmenize izin veren bir where cümlesi kullanabilirsiniz.

Swift 2:

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

Hızlı 3 ve 4:

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

veya daha güçlü where cümlesi:

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

Elbette protokol bileşimini kullanabilirsiniz (örneğin protocol<SomeProtocol, SomeOtherProtocol>), ancak biraz daha az esnektir.

Kullanmak where, birden fazla türün dahil olduğu vakalarla ilgilenmenize olanak tanır.

Yine de birden fazla yerde yeniden kullanılmak üzere protokoller oluşturmak veya sadece oluşturulan protokole anlamlı bir ad vermek isteyebilirsiniz.

Swift 5:

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

Protokoller argümanın yanında olduğu için bu daha doğal geliyor.

İki seçeneğiniz var:

1. Jiaaro'nun cevabında belirtildiği gibi bir where cümlesi kullanıyorsunuz :

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

2. Bir protokol oluşturma türü kullanıyorsunuz :

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

Swift 3.0'daki evrim bazı değişiklikler getiriyor. İki seçeneğimiz şimdi biraz farklı görünüyor.

whereSwift 3.0'da bir cümle kullanmak :

Yan wheretümce, okunabilirliği artırmak için artık bir işlev imzasının sonuna taşınmıştır. Yani çoklu protokol kalıtımı artık şu şekilde görünüyor:

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

}

Kullanma protocol<>Swift 3.0 yapısı:

Yapıyı kullanan kompozisyon protocol<>kullanımdan kaldırılıyor. Daha önce protocol<SomeProtocol, SomeOtherProtocol>şuna benziyor:

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

}

Referanslar.

İçin değişiklikler hakkında daha fazla bilgi whereburada: https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md

Ve <> protokol yapısındaki değişiklikler hakkında daha fazla bilgi burada: https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md

Swift 3, işlevinizi açıklamanın 3 farklı yolunu sunar.

protocol SomeProtocol {
    /* ... */
}

protocol SomeOtherProtocol {
    /* ... */        
}

1. &Operatörü kullanma

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

2. wheremadde kullanma

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

3. whereMadde ve &operatör kullanma

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

Ayrıca typealiasişlev bildiriminizi kısaltmak için kullanabileceğinizi unutmayın .

typealias RequiredProtocols = SomeProtocol & SomeOtherProtocol

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