स्विफ्ट में जेनरिक की शक्ति। भाग २

शुभ दोपहर, दोस्तों। विशेष रूप से पाठ्यक्रम "iOS डेवलपर" के छात्रों के लिए । एडवांस्ड कोर्स ”, हमने“ स्विफ्ट में जेनरिक की शक्ति ”लेख के दूसरे भाग का अनुवाद तैयार किया।

---

संबंधित प्रकार, जहां खंड, सदस्यता, और बहुत कुछ ...

लेख "स्विफ्ट में जेनरिक की शक्ति। भाग 1 " सामान्य कार्य, सामान्य प्रकार और प्रतिबंधों का वर्णन किया गया है। यदि आप एक शुरुआती हैं, तो मैं आपको सलाह दूंगा कि आप बेहतर समझ के लिए पहले भाग को पढ़ें।

किसी प्रोटोकॉल को परिभाषित करते समय, परिभाषा के हिस्से के रूप में एक या अधिक संबंधित प्रकारों को घोषित करना कभी-कभी उपयोगी होता है। संबंधित प्रकार प्रोटोकॉल के भाग के रूप में उपयोग किए जाने वाले स्टब नाम को निर्दिष्ट करता है। इस संबंधित प्रकार के लिए उपयोग किए जाने वाले वास्तविक प्रकार को तब तक निर्दिष्ट नहीं किया जाएगा जब तक कि प्रोटोकॉल का उपयोग न किया जाए। संबद्ध प्रकार को associatedtype कीवर्ड का उपयोग करके घोषित किया जाता है।

हम उस स्टैक के लिए प्रोटोकॉल को परिभाषित कर सकते हैं जिसे हमने पहले भाग में बनाया था।

 protocol Stackable { associatedtype Element mutating func push(element: Element) mutating func pop() -> Element? func peek() throws -> Element func isEmpty() -> Bool func count() -> Int subscript(i: Int) -> Element { get } } 

Stackable प्रोटोकॉल आवश्यक कार्यक्षमता को परिभाषित करता है जो किसी भी स्टैक को प्रदान करना चाहिए।

किसी भी प्रकार जो Stackable प्रोटोकॉल के अनुरूप है, वह उस स्टोर के प्रकार को निर्दिष्ट करने में सक्षम होना चाहिए। यह सुनिश्चित करना चाहिए कि स्टैक में केवल सही प्रकार के तत्व जोड़े जाते हैं, और यह स्पष्ट होना चाहिए कि किस प्रकार के तत्व इसकी उपधारा द्वारा वापस किए गए हैं।

चलो प्रोटोकॉल के अनुसार हमारे स्टैक को बदलते हैं:

 enum StackError: Error { case Empty(message: String) } protocol Stackable { associatedtype Element mutating func push(element: Element) mutating func pop() -> Element? func peek() throws -> Element func isEmpty() -> Bool func count() -> Int subscript(i: Int) -> Element { get } } public struct Stack<T>: Stackable { public typealias Element = T var array: [T] = [] init(capacity: Int) { array.reserveCapacity(capacity) } public mutating func push(element: T) { array.append(element) } public mutating func pop() -> T? { return array.popLast() } public func peek() throws -> T { guard !isEmpty(), let lastElement = array.last else { throw StackError.Empty(message: "Array is empty") } return lastElement } func isEmpty() -> Bool { return array.isEmpty } func count() -> Int { return array.count } } extension Stack: Collection { public func makeIterator() -> AnyIterator<T> { var curr = self return AnyIterator { curr.pop() } } public subscript(i: Int) -> T { return array[i] } public var startIndex: Int { return array.startIndex } public var endIndex: Int { return array.endIndex } public func index(after i: Int) -> Int { return array.index(after: i) } } extension Stack: CustomStringConvertible { public var description: String { let header = "***Stack Operations start*** " let footer = " ***Stack Operation end***" let elements = array.map{ "\($0)" }.joined(separator: "\n") return header + elements + footer } } var stack = Stack<Int>(capacity: 10) stack.push(element: 1) stack.pop() stack.push(element: 3) stack.push(element: 4) print(stack) 

संबंधित प्रकार को इंगित करने के लिए मौजूदा प्रकार का विस्तार करना

आप प्रोटोकॉल का पालन करने के लिए एक मौजूदा प्रकार का विस्तार कर सकते हैं।

 protocol Container { associatedtype Item mutating func append(_ item: Item) var count: Int { get } subscript(i: Int) -> Item { get } } extension Array: Container {} 

संबंधित प्रकार से बाधाओं को जोड़ना:

आप प्रोटोकॉल में संबंधित प्रकार के प्रतिबंध को यह सुनिश्चित करने के लिए जोड़ सकते हैं कि संबंधित प्रकार इन प्रतिबंधों का अनुपालन करते हैं।
Stackable प्रोटोकॉल को बदलते हैं।

 protocol Stackable { associatedtype Element: Equatable mutating func push(element: Element) mutating func pop() -> Element? func peek() throws -> Element func isEmpty() -> Bool func count() -> Int subscript(i: Int) -> Element { get } } 

अब स्टैक तत्व का प्रकार Equatable मेल Equatable चाहिए, अन्यथा एक संकलन-समय त्रुटि होगी।

पुनरावर्ती प्रोटोकॉल प्रतिबंध:

प्रोटोकॉल अपनी आवश्यकताओं का हिस्सा हो सकता है।

 protocol SuffixableContainer: Container { associatedtype Suffix: SuffixableContainer where Suffix.Item == Item func suffix(_ size: Int) -> Suffix } 

Suffix की दो सीमाएँ हैं: इसे SuffixableContainer प्रोटोकॉल (प्रोटोकॉल यहाँ परिभाषित किया गया है) के साथ पालन करना चाहिए, और इसके Item प्रकार को कंटेनर के Item प्रकार से मेल खाना चाहिए।

इस विषय Protocol Sequence स्पष्ट Protocol Sequence में स्विफ्ट मानक पुस्तकालय का एक अच्छा उदाहरण है।

पुनरावर्ती प्रोटोकॉल की सीमाओं का प्रस्ताव: https://github.com/apple/swift-evolution/blob/master/proposals/0157-recursive-protocol-constraints.md

सामान्य प्रकार के एक्सटेंशन:

जब आप एक सामान्य प्रकार का विस्तार करते हैं, तो आप एक्सटेंशन को परिभाषित करते समय प्रकार के मापदंडों की सूची का वर्णन नहीं कर रहे हैं। इसके बजाय, स्रोत परिभाषा से प्रकार पैरामीटर की एक सूची विस्तार निकाय में उपलब्ध है, और स्रोत प्रकार के पैरामीटर नाम का उपयोग स्रोत परिभाषा से प्रकार पैरामीटर को संदर्भित करने के लिए किया जाता है।

 extension Stack { var topItem: Element? { return items.isEmpty ? nil : items[items.count - 1] } } 

जेनेरिक जहां क्लॉज

संबंधित प्रकारों के लिए, यह आवश्यकताओं को परिभाषित करने के लिए उपयोगी है। आवश्यकता का वर्णन जेनेरिक द्वारा किया जाता है जहां खंड । जेनेरिक where क्लॉज आपको यह अनुमति देता है कि संबंधित प्रकार एक विशिष्ट प्रोटोकॉल के अनुरूप है या कि कुछ प्रकार के पैरामीटर और संबंधित प्रकार समान हैं। जेनेरिक where क्लॉज where कीवर्ड से शुरू होता है, उसके बाद संबंधित प्रकारों के लिए बाधाओं या प्रकारों और संबंधित प्रकारों के बीच समानता का संबंध होता है। जेनेरिक where क्लॉज टाइप या फ़ंक्शन बॉडी के उद्घाटन ब्रेस से ठीक पहले लिखा जाता है।

 func allItemsMatch<C1: Container, C2: Container> (_ someContainer: C1, _ anotherContainer: C2) -> Bool where C1.Item == C2.Item, C1.Item: Equatable { } 

जहां सामान्य परिस्थितियों के साथ एक्सटेंशन

आप जेनेरिक का उपयोग कर सकते हैं where विस्तार के हिस्से के रूप में खंड। निम्न उदाहरण isTop (_ :) विधि को जोड़कर पिछले उदाहरणों की समग्र Stack संरचना का विस्तार करता है।

 extension Stack where Element: Equatable { func isTop(_ item: Element) -> Bool { guard let topItem = items.last else { return false } return topItem == item } } 

एक्सटेंशन isTop (_ :) विधि को केवल तभी जोड़ता है जब स्टैक समर्थन पर आइटम समान हो। आप उस जेनरिक का भी उपयोग कर सकते हैं where प्रोटोकॉल एक्सटेंशन के साथ क्लॉज है। आप उन्हें अल्पविराम where अलग where कई आवश्यकताएं जोड़ सकते हैं।

जेनेरिक क्लॉज के साथ संबद्ध प्रकार जहां:

आप उस जेनेरिक को शामिल कर सकते हैं where संबद्ध प्रकार में क्लॉज़ है।

 protocol Container { associatedtype Item mutating func append(_ item: Item) var count: Int { get } subscript(i: Int) -> Item { get } associatedtype Iterator: IteratorProtocol where Iterator.Element == Item func makeIterator() -> Iterator } 

एक प्रोटोकॉल के लिए जो दूसरे प्रोटोकॉल से विरासत में मिला है, आप जेनेरिक where प्रोटोकॉल घोषणा में खंड सहित विरासत में बंधे प्रकार के लिए एक बाधा जोड़ते हैं। उदाहरण के लिए, निम्न कोड एक ComparableContainer प्रोटोकॉल की घोषणा करता है जिसके Item Comparable Item समर्थन Item लिए Item आवश्यकता होती है:

 protocol ComparableContainer: Container where Item: Comparable { } 

सामान्य प्रकार के उपनाम:

टाइप उर्फ ​​में सामान्य पैरामीटर हो सकते हैं। यह अभी भी एक उपनाम (यानी, यह एक नए प्रकार का परिचय नहीं देगा) रहेगा।

 typealias StringDictionary<Value> = Dictionary<String, Value> var d1 = StringDictionary<Int>() var d2: Dictionary<String, Int> = d1 // okay: d1 and d2 have the same type, Dictionary<String, Int> typealias DictionaryOfStrings<T : Hashable> = Dictionary<T, String> typealias IntFunction<T> = (T) -> Int typealias Vec3<T> = (T, T, T) typealias BackwardTriple<T1,T2,T3> = (T3, T2, T1) 

इस तंत्र में, प्रकार के मापदंडों के अतिरिक्त प्रतिबंधों का उपयोग नहीं किया जा सकता है।
ऐसा कोड काम नहीं करेगा:

 typealias ComparableArray<T where T : Comparable> = Array<T> 

जेनेरिक सुपरस्क्रिप्ट

सदस्यता जेनेरिक तंत्र का उपयोग कर सकती है और जेनेरिक को शामिल कर सकती है where क्लॉज। आप subscript बाद एंगल ब्रैकेट्स में टाइप नाम लिखें, और जेनेरिक लिखें where सबस्क्रिप्ट बॉडी के ओपनिंग ब्रेस से तुरंत पहले क्लॉज हो।

 extension Container { subscript<Indices: Sequence>(indices: Indices) -> [Item] where Indices.Iterator.Element == Int { var result = [Item]() for index in indices { result.append(self[index]) } return result } } 

सामान्य विशेषज्ञता

जेनेरिक विशेषज्ञता का मतलब है कि कंपाइलर एक विशेष प्रकार के पैरामीटर जैसे कि इंट के लिए एक सामान्य प्रकार या फ़ंक्शन, जैसे स्टैक < टी > क्लोन करता है। इस विशेष फ़ंक्शन को विशेष रूप से इंट के लिए अनुकूलित किया जा सकता है, जबकि वह सब जो अतिश्योक्तिपूर्ण है हटा दिया जाएगा। संकलन समय पर टाइप तर्कों के साथ प्रकार के मापदंडों को बदलने की प्रक्रिया को विशेषज्ञता कहा जाता है ।

इन प्रकारों के लिए सामान्य फ़ंक्शन को विशेषज्ञता देकर, हम आवश्यक होने पर वर्चुअल डिस्पैचिंग, इनलाइन कॉल की लागत को समाप्त कर सकते हैं और सामान्य प्रणाली के ओवरहेड को समाप्त कर सकते हैं।

संचालक अधिभार

सामान्य प्रकार डिफ़ॉल्ट रूप से ऑपरेटरों के साथ काम नहीं करते हैं, इसके लिए आपको एक प्रोटोकॉल की आवश्यकता होती है।

 func ==<T: Equatable>(lhs: Matrix<T>, rhs: Matrix<T>) -> Bool { return lhs.array == rhs.array } 

जेनरिक के बारे में एक दिलचस्प बात

आप सामान्य प्रकार के लिए स्थिर संग्रहीत संपत्ति को परिभाषित क्यों नहीं कर सकते?

इसके लिए प्रत्येक व्यक्तिगत जेनेरिक (T) विशेषज्ञता के लिए गुणों के एक अलग भंडारण की आवश्यकता होगी।

गहन अध्ययन के लिए संसाधन:

https://github.com/apple/swift/blob/master/docs/Generics.rst
https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md
https://developer.apple.com/videos/play/wwdc2018/406/
https://www.youtube.com/watch?v=ctS8FzqcRug
https://medium.com/@vhart/protocols-generics-and-existential-containers-wait-what-e2e698262ab1


वह सब है। कोर्स पर मिलते हैं ।