गो में इंटरफेस और कंक्रीट प्रकारों के साथ जेनेरिक आरंभीकरण

गो में सामान्य फ़ंक्शन लिखते समय, कंक्रीट प्रकारों को स्वीकार करना भी फायदेमंद हो सकता है। हालाँकि, उन विशिष्ट प्रकारों के नए उदाहरणों के साथ इंटरफेस के स्लाइस को आरंभ करने का प्रयास करते समय यह एक चुनौती पैदा करता है। एक स्लाइस एलिमेंट प्रकार (X) के लिए और दूसरा कंक्रीट प्रकार (Y) के लिए इंस्टेंटियेट करने के लिए। हालाँकि, X प्रकार के तत्व को Y का एक उदाहरण निर्दिष्ट करने का प्रयास करते समय यह दृष्टिकोण विफल हो जाता है।

func fill[X, Y Any](slice []X){ मेरे लिए := रेंज स्लाइस { स्लाइस[i] = नया(Y) // काम नहीं! } }

यह समस्या इसलिए उत्पन्न होती है क्योंकि कंपाइलर इंटरफ़ेस X और इसके कार्यान्वयन Y के बीच संबंध खो देता है। ]इसे संबोधित करने के लिए, कोई फ़ंक्शन के भीतर एक स्पष्ट कास्टिंग ऑपरेशन नियोजित कर सकता है:

func Fill[X, Y any](slice []X){
   for i := range slice {
      slice[i] = new(Y) // not work!
   }
}

func fill[X, Y कोई भी](स्लाइस []X) { मेरे लिए := रेंज स्लाइस { स्लाइस[i] = कोई(*नया(Y)).(X) } }

हालाँकि, यदि Y, X को लागू नहीं करता है तो यह दृष्टिकोण घबराहट पैदा करता है, जो ऐसे परिदृश्यों में होता है जैसे कि sync.Locker को *sync.Mutex (पॉइंटर प्रकार) असाइन करने का प्रयास करना।

एक कंस्ट्रक्टर फ़ंक्शन का उपयोग करना

एक अधिक मजबूत और प्रकार-सुरक्षित समाधान में एक कंस्ट्रक्टर फ़ंक्शन का उपयोग शामिल है:

func Fill[X, Y any](slice []X){
   for i := range slice {
      slice[i] = new(Y) // not work!
   }
}

func fill[X Any](slice []X, f func() X ) { मेरे लिए := रेंज स्लाइस { स्लाइस[i] = f() } }

यह फ़ंक्शन एक कंस्ट्रक्टर फ़ंक्शन को स्वीकार करता है जो निर्दिष्ट प्रकार का एक नया उदाहरण लौटाता है। यह ठोस प्रकार के उदाहरणों के साथ स्लाइस के संक्षिप्त और सुरक्षित आरंभीकरण की अनुमति देता है। उस new(Y) का परिणाम शून्य मान होगा। इसे रोकने के लिए, कोई सही पॉइंटर मान वापस करने के लिए कंस्ट्रक्टर फ़ंक्शन को समायोजित कर सकता है, जैसे कि func() X { return &sync.Mutex{} }।