Generic — सामान्य प्रकारों का सार और T पैरामीटर

Swift में Generic क्या है?

Generic (सामान्य प्रकार) — Swift में एक सिंटैक्स संरचना है जो प्रकार पैरामीटरिक्षण के साथ लचीला, पुनःप्रयोज्य कोड लिखने की अनुमति देती है। विशिष्ट प्रकार के बजाय, एक प्लेसहोल्डर कोणाक्र ब्रैकेट में लिखा जाता है — आमतौर पर , लेकिन किसी भी नाम का उपयोग किया जा सकता है। Generics SwiftUI (View, some View), स्टैंडर्ड लाइब्रेरी (Array, Optional) और Combine का आधार हैं।

ग्जेनरिक्स की जरूरत क्यों है

ग्जेनरिक्स के बिना, आपको प्रत्येक प्रकार के लिए अलग-अलग फ़ंक्शन लिखने होंगे: swapInts, swapStrings, swapDates. एक generic swap फ़ंक्शन तीनों वैरिएंट्स को एक ही घोषणा से बदल देता है। यह दुहराव कम करता है, पढ़ने योग्यता बढ़ाता है और कोड कॉपी करते समय त्रुटियों की संभावना कम करता है।

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 10
var y = 20
swapValues(&x, &y)

Swift कंपाइलर generic के प्रत्येक विशिष्ट उपयोग के लिए विशेषीकृत कोड उत्पन्न करता है। इसका मतलब है कि generic फ़ंक्शन swapValues का Int के लिए हाथ से लिखे फ़ंक्शन की तुलना में कोई ओवरहेड नहीं है। Swift Java की तरह टाइप इरेजर का उपयोग नहीं करता — generics कंपाइल टाइम और रनटाइम दोनों में मौजूद हैं (हालांकि ऑप्टिमिजेशन उन्हें विशेषीकृत कर सकता है)।

पैरामीटर T के साथ सामान्य फ़ंक्शन

सामान्य फ़ंक्शन वे फ़ंक्शन हैं जो एक या अधिक प्रकार पैरामीटर स्वीकार करते हैं। प्रकार पैरामीटर फ़ंक्शन के नाम के बाद कोणाक्र ब्रैकेट में निर्दिष्ट किए जाते हैं: . इनका उपयोग हस्ताक्षर में किया जा सकता है: आर्गुमेंट प्रकार, रिटर्न प्रकार और फ़ंक्शन बॉडी के अंदर।

एकाधिक प्रकार पैरामीटर

एक फ़ंक्शन में एकाधिक generic पैरामीटर हो सकते हैं। उदाहरण के लिए, फ़ंक्शन findKey कुंजी K और मान V के साथ एक शब्दकोश लेता है। प्रत्येक प्रकार पैरामीटर अनोखा है और बन्धनों में उपयोग किया जा सकता है।

func findKey<K: Hashable, V>(
    for value: V,
    in dictionary: [K: V]
) -> K? where V: Equatable {
    for (key, dictValue) in dictionary {
        if dictValue == value {
            return key
        }
    }
    return nil
}

बन्धन K: Hashable और where V: Equatable सुनिश्चित करते हैं कि findKey केवल एक शब्दकोश के साथ ही बुलाया जा सकता है जिसकी कुंजीं हैशेबल और मान इक्विटेबल हैं। ऐसे बन्धन नौकरशाही नहीं बल्कि आवश्यकता हैं: Hashable के बिना आप कुंजी लूकअप को इंडेक्स नहीं कर सकते, Equatable के बिना आदिबि की value से तुलना नहीं कर सकते।

where के माध्यम से प्रकार बन्धन

where — Swift की एक कीवर्ड है जो generic पैरामीटरों पर अतिरिक्त बन्धन लगाता है। कोणाक्र ब्रैकेट () में मात्र एक प्रोटोकॉल निर्दिष्ट करने के विपरीत, where अधिक जटिल स्थितियों को व्यक्त करने की अनुमति देता है: एकाधिक प्रोटोकॉल का अनुपालन, प्रकार पैरामीटरों के बीच संबंध, और संबद्ध प्रकारों का रिफाइनमेंट।

where सिंटैक्स

where क्लॉज़ फ़ंक्शन या प्रकार हस्ताक्षर के बाद, खुलने वाले ब्रेस से पहले लिखा जाता है। where में आप निर्दिष्ट कर सकते हैं कि T: Comparable & Hashable (एक साथ दो प्रोटोकॉल्स का अनुसरण करता है), या T.U == Int (एक संबद्ध प्रकार को मूर्त करता है)।

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
}

extension Container where Item: Comparable {
    func isSorted() -> Bool {
        // Implementation available only if Item: Comparable
        return true
    }
}

where के साथ एक्सटेंशन केवल उन प्रकारों के लिए ही विधियाँ जोड़ता है जो शर्त को पूरा करते हैं। Container को isSorted विधि मिलेगी, जबकि Container को नहीं मिलेगी, क्योंकि Any Comparable नहीं है। यह सार्तिक कार्यक्षमता का एक शक्तिशाली तन्त्र है।

प्रोटोकॉल में Associated Types

Associated Types (संबद्ध प्रकार) — प्रोटोकॉल को घोषणा चरण में विशिष्ट प्रकार निर्दिष्ट किए बिना सामान्य बनाने का एक तरीका है। के बजाय, प्रोटोकॉल एक associatedtype घोषित करता है, जो कार्यान्वयन में मूर्त होता है। यह विशेष रूप से संग्रहों के लिए महत्वपूर्ण है: Sequence प्रोटोकॉल नहीं जानता कि अनुक्रम में कौन से तत्व होंगे।

where के माध्यम से Associated Types को जोड़ना

where का उपयोग करके आप विभिन्न प्रोटोकॉल्स के associated types के बीच संबंध स्थापित कर सकते हैं। उदाहरण के लिए, आप आवश्यकता रख्वा सकते हैं कि एक प्रोटोकॉल का Item दूसरे के Iterator.Element से मेल खाता हो। यह कंपाइलर स्तर पर प्रकार अनुकूलता सुनिश्चित करता है।

protocol StackProtocol {
    associatedtype Element
    mutating func push(_ item: Element)
    mutating func pop() -> Element?
}

struct IntStack: StackProtocol {
    typealias Element = Int
    private var items: [Int] = []
    
    mutating func push(_ item: Int) { items.append(item) }
    mutating func pop() -> Int? { items.popLast() }
}

IntStack typealias का उपयोग करके Element को Int के रूप में मूर्त करता है। कंपाइलर जाँचता है कि प्रोटोकॉल की सभी आवश्यकताएँ इस प्रकार के साथ पूरी होती हैं। associated types के बिना, आपको एक generic प्रोटोकॉल के सاथ StackProtocol लिखना होगा, लेकिन Swift Objective-C ब्रिज़ के साथ संगति और बेहतर पढ़ने योग्यता के लिए associated types का उपयोग करता है।

एक्सटेंशन और सबस्क्रिप्ट में Generic

Generic एक्सटेंशन अतिरिक्त बन्धनों के साथ एक generic प्रकार में विधियाँ जोड़ने की अनुमति देते हैं। यह सार्तिक अनुरूपता पैटर्न है, जहाँ एक प्रकार को केवल निश्चित शर्तों में ही कार्यक्षमता मिलती है। सबस्क्रिप्ट भी generic हो सकते हैं।

Generic सबस्क्रिप्ट

एक सबस्क्रिप्ट generic हो सकता है: यह कोणाक्र ब्रैकेट में generic पैरामीटर स्वीकार करता है। यह मनमानी इंडेक्स के साथ संग्रहों तक सुरक्षित पहुंच के लिए उपयोगी है, जहाँ इंडेक्स विभिन्न प्रकार का हो सकता है।

extension Array where Element: Numeric {
    func sum() -> Element {
        return reduce(0, +)
    }
}

extension Array {
    subscript<Indices: Sequence>(indices: Indices) -> [Element]
        where Indices.Element == Int {
        return indices.map { self[$0] }
    }
}

यह संरचना शक्तिशाली संरचना प्रदान करती है: sum विधि केवल संख्यात्मक एरे पर दिखाई देती है, और मनमानी इंडेक्स वाला सबस्क्रिप्ट पूर्णांक इंडेक्स के किसी भी अनुक्रम के साथ काम करता है। कंपाइलर where शर्तों के आधार पर इन सदस्यों की दृश्यता का प्रबंधन स्वयं करता है।

Generic के साथ काम करते समय सामान्य गलतियाँ

गलतियाँ generic का उपयोग करते समय अक्सर गलत बन्धनों या जहाँ विशिष्ट प्रकार की आवश्यकता है वहाँ generic का उपयोग करने के प्रयास से संबंधित होती हैं। आइए तीन सामान्य परिदृश्यों को देखें जिनका डिवेलपरों को सामना करना पड़ता है।

अत्यधिक पैरामीटरीकरण

जहाँ विशिष्ट प्रकार पर्याप्त है वहाँ generic पैरामीटर जोड़ना एक प्रतिस्वरूप है। यदि कोई फ़ंक्शन हमेशा String के साथ काम करता है, तो उसे बनाने की जरूरत नहीं है। यह बिना लाभ के कोड को जटिल करता है। Generic उचित होता है जब प्रकार वास्तव में भिन्न होता है, न कि अमूर्त विकास लचीलेपन के लिए।

where बन्धन का अभाव

यह निर्दिष्ट किए बिना कि विधि मौजूद है, generic पैरामीटर पर किसी विधि को कॉल करना एक त्रुटि है। .count को कॉल नहीं कर सकता है जब तक कि T: Collection निर्दिष्ट न हो। हमेशा प्रकार पैरामीटरों पर बन्धन जोड़ें, नहीं तो कंपाइलर कोड को अस्वीकार कर देगा।

// ❌ Error: value has no count method
func countElements<T>(value: T) -> Int { value.count }

// ✅ Works: T: Collection guarantees count exists
func countElements<T: Collection>(value: T) -> Int { value.count }

त्रुटि स्पष्ट है: generic कोई भी प्रकार हो सकता है, और कंपाइलर नहीं जानता कि इसके पास count है या नहीं। Collection बन्धन समस्या का समाधान करता है। इसी प्रकार Equatable, Hashable, Numeric के लिए — यदि आप generic पैरामीटर पर विधियाँ या ऑपरेटर कॉल करने की योजना बना रहे हैं तो हमेशा प्रोटोकॉल निर्दिष्ट करें।