ข้อ จำกัด หลายประเภทใน 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>

คุณสามารถใช้คำสั่ง whereซึ่งช่วยให้คุณระบุข้อกำหนดได้มากเท่าที่คุณต้องการ (ซึ่งทั้งหมดจะต้องเป็นไปตามนั้น) คั่นด้วยลูกน้ำ

Swift 2:

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

Swift 3 และ 4:

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

หรือมีประสิทธิภาพมากขึ้นโดยที่ clause:

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

แน่นอนคุณสามารถใช้องค์ประกอบโปรโตคอล (เช่นprotocol<SomeProtocol, SomeOtherProtocol>) แต่มีความยืดหยุ่นน้อยกว่าเล็กน้อย

การใช้whereช่วยให้คุณจัดการกับกรณีที่เกี่ยวข้องกับหลายประเภท

คุณอาจยังต้องการสร้างโปรโตคอลเพื่อใช้ซ้ำในหลาย ๆ ที่หรือเพียงเพื่อตั้งชื่อที่มีความหมายให้โปรโตคอลที่สร้างขึ้น

สวิฟต์ 5:

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

สิ่งนี้ให้ความรู้สึกเป็นธรรมชาติมากขึ้นเนื่องจากโปรโตคอลอยู่ถัดจากการโต้แย้ง

คุณมีความเป็นไปได้สองประการ:

1. คุณใช้where clauseตามที่ระบุไว้ในคำตอบของ Jiaaro:

   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

และข้อมูลเพิ่มเติมเกี่ยวกับการเปลี่ยนแปลงของโครงสร้างโปรโตคอล <> อยู่ที่นี่: 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) {
    /* ... */   
}