सामान्य प्रोग्रामिंग

Not to be confused with Genetic programming.

जेनेरिक प्रोग्रामिंग कंप्यूटर प्रोग्रामिंग की एक शैली है जिसमें कलन विधि को डेटा प्रकार टू-बी-स्पेसिफाइड-लेटर के संदर्भ में लिखा जाता है, जो पैरामीटर (कंप्यूटर प्रोग्रामिंग) के रूप में प्रदान किए गए विशिष्ट प्रकारों के लिए आवश्यक होने पर तत्काल होते हैं। 1973 में ML (प्रोग्रामिंग लैंग्वेज) प्रोग्रामिंग लैंग्वेज द्वारा बीड़ा उठाया गया यह दृष्टिकोण, सामान्य कार्य (कंप्यूटर विज्ञान) या प्रकार (कंप्यूटर विज्ञान) लिखने की अनुमति देता है जो केवल उन प्रकारों के सेट में भिन्न होता है जिन पर वे उपयोग किए जाने पर काम करते हैं, इस प्रकार डुप्लिकेट कोड को कम करते हैं। एडा (प्रोग्रामिंग भाषा), सी शार्प (प्रोग्रामिंग लैंग्वेज) | सी #, डेल्फी (प्रोग्रामिंग भाषा), एफिल (प्रोग्रामिंग लैंग्वेज), एफ शार्प (प्रोग्रामिंग लैंग्वेज) | एफ #, जावा (प्रोग्रामिंग भाषा) में ऐसी सॉफ्टवेयर संस्थाओं को जेनरिक के रूप में जाना जाता है। निम_(प्रोग्रामिंग_लैंग्वेज), पायथन (प्रोग्रामिंग लैंग्वेज), जाओ (प्रोग्रामिंग भाषा), जंग (प्रोग्रामिंग भाषा), स्विफ्ट (प्रोग्रामिंग भाषा), टाइपप्रति और विजुअल बेसिक .NET। उन्हें एमएल (प्रोग्रामिंग भाषा), स्काला (प्रोग्रामिंग भाषा), जूलिया (प्रोग्रामिंग भाषा), और हास्केल (प्रोग्रामिंग भाषा) में पैरामीट्रिक बहुरूपता के रूप में जाना जाता है (हास्केल समुदाय संबंधित लेकिन कुछ अलग अवधारणा के लिए सामान्य शब्द का भी उपयोग करता है); सी ++ और डी (प्रोग्रामिंग भाषा) में टेम्पलेट (सी ++)एस; और 1994 की प्रभावशाली पुस्तक डिजाइन पैटर्न (पुस्तक)पुस्तक) में पैरामीटरयुक्त प्रकार। जेनेरिक प्रोग्रामिंग शब्द मूल रूप से डेविड मूसर और अलेक्जेंडर स्टेपानोव द्वारा गढ़ा गया था उपरोक्त की तुलना में अधिक विशिष्ट अर्थ में, एक प्रोग्रामिंग प्रतिमान का वर्णन करने के लिए जिसके द्वारा प्रकारों पर मौलिक आवश्यकताओं को एल्गोरिदम और डेटा संरचनाओं के ठोस उदाहरणों से सारगर्भित किया जाता है और अवधारणा (जेनेरिक प्रोग्रामिंग) के रूप में औपचारिक रूप दिया जाता है, इन अवधारणाओं के संदर्भ में सामान्य कार्यों को लागू किया जाता है, आमतौर पर जैसा कि ऊपर वर्णित है, भाषा सामान्यता तंत्र का उपयोग करना।

स्टेपानोव-मुसर और अन्य सामान्य प्रोग्रामिंग प्रतिमान

सामान्य प्रोग्रामिंग में परिभाषित किया गया है Musser & Stepanov (1989) निम्नलिखित नुसार,

Generic programming centers around the idea of abstracting from concrete, efficient algorithms to obtain generic algorithms that can be combined with different data representations to produce a wide variety of useful software.

— Musser, David R.; Stepanov, Alexander A., Generic Programming

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

उदाहरण के लिए, दिए गए एन अनुक्रम डेटा संरचनाएं, उदा। सिंगल लिंक्ड लिस्ट, वेक्टर आदि, और उन पर काम करने के लिए एम एल्गोरिदम, उदा। find, sort आदि, एक सीधा दृष्टिकोण प्रत्येक एल्गोरिथ्म को विशेष रूप से प्रत्येक डेटा संरचना के लिए लागू करेगा, दे रहा है N × M लागू करने के लिए संयोजन। हालाँकि, सामान्य प्रोग्रामिंग दृष्टिकोण में, प्रत्येक डेटा संरचना एक पुनरावर्तक अवधारणा का एक मॉडल लौटाती है (एक साधारण मान प्रकार जिसे वर्तमान मान को पुनः प्राप्त करने के लिए संदर्भित किया जा सकता है, या अनुक्रम में किसी अन्य मान को इंगित करने के लिए बदला जा सकता है) और इसके बजाय प्रत्येक एल्गोरिथ्म लिखा जाता है आम तौर पर ऐसे पुनरावर्तकों के तर्कों के साथ, उदा। पुनरावृत्तियों की एक जोड़ी प्रक्रिया के बाद या सीमा की शुरुआत और अंत की ओर इशारा करती है। इस प्रकार, केवल N + M डेटा संरचना-एल्गोरिदम संयोजनों को लागू करने की आवश्यकता है। एसटीएल में कई पुनरावर्तक अवधारणाएँ निर्दिष्ट हैं, प्रत्येक अधिक प्रतिबंधात्मक अवधारणाओं का परिशोधन है उदा। अग्रेषित पुनरावर्तक केवल अनुक्रम में अगले मूल्य के लिए आंदोलन प्रदान करते हैं (उदाहरण के लिए एक एकल लिंक्ड सूची या इनपुट डेटा की धारा के लिए उपयुक्त), जबकि एक यादृच्छिक-पहुंच पुनरावर्तक अनुक्रम के किसी भी तत्व (उदाहरण के लिए उपयुक्त) के लिए प्रत्यक्ष निरंतर-समय तक पहुंच प्रदान करता है एक वेक्टर के लिए)। एक महत्वपूर्ण बिंदु यह है कि एक डेटा संरचना सबसे सामान्य अवधारणा का एक मॉडल लौटाती है जिसे कुशलता से कार्यान्वित किया जा सकता है-एल्गोरिदम आवश्यकताओं का विश्लेषण स्पष्ट रूप से अवधारणा परिभाषा का हिस्सा है। यह उन डेटा संरचनाओं को सीमित करता है जिन पर किसी दिए गए एल्गोरिदम को लागू किया जा सकता है और ऐसी जटिलता आवश्यकताएं डेटा संरचना पसंद का एक प्रमुख निर्धारक हैं। सामान्य प्रोग्रामिंग इसी तरह अन्य डोमेन में लागू की गई है, उदा। ग्राफ एल्गोरिदम। ध्यान दें कि यद्यपि यह दृष्टिकोण अक्सर संकलन-समय की सामान्यता/टेम्पलेट्स की भाषा सुविधाओं का उपयोग करता है, यह वास्तव में विशेष भाषा-तकनीकी विवरणों से स्वतंत्र है। जेनेरिक प्रोग्रामिंग अग्रणी अलेक्जेंडर स्टेपानोव ने लिखा,

Generic programming is about abstracting and classifying algorithms and data structures. It gets its inspiration from Knuth and not from type theory. Its goal is the incremental construction of systematic catalogs of useful, efficient and abstract algorithms and data structures. Such an undertaking is still a dream.

— Alexander Stepanov, Short History of STL

I believe that iterator theories are as central to Computer Science as theories of rings or Banach spaces are central to Mathematics.

— Alexander Stepanov, An Interview with A. Stepanov

बज़्ने स्ट्रॉस्ट्रुप ने कहा,

Following Stepanov, we can define generic programming without mentioning language features: Lift algorithms and data structures from concrete examples to their most general and abstract form.

— Bjarne Stroustrup, Evolving a language in and for the real world: C++ 1991-2006

अन्य प्रोग्रामिंग प्रतिमान जिन्हें जेनेरिक प्रोग्रामिंग के रूप में वर्णित किया गया है, उनमें जेनरिक प्रोग्रामिंग - एक परिचय में वर्णित डेटाटाइप जेनेरिक प्रोग्रामिंग शामिल है। Scrap your boilerplate }} दृष्टिकोण हास्केल के लिए एक हल्का सामान्य प्रोग्रामिंग दृष्टिकोण है। इस लेख में हम ऊपर दिए गए जेनेरिक प्रोग्रामिंग के उच्च-स्तरीय प्रोग्रामिंग प्रतिमानों को निम्न-स्तरीय प्रोग्रामिंग लैंग्वेज जेनरिकिटी मैकेनिज्म से अलग करते हैं, जिसका उपयोग उन्हें लागू करने के लिए किया जाता है (जेनेरिकिटी के लिए प्रोग्रामिंग लैंग्वेज सपोर्ट देखें)। आगे की चर्चा और सामान्य प्रोग्रामिंग प्रतिमानों की तुलना के लिए, देखें।

उदारता के डी प्रोग्रामिंग भाषा समर्थन

एमएल (प्रोग्रामिंग लैंग्वेज), सीएलयू प्रोग्रामिंग भाषा और एडा प्रोग्रामिंग भाषा जैसी भाषाओं में कम से कम 1970 के दशक से उच्च-स्तरीय भाषाओं में सामान्यता सुविधाएं मौजूद हैं, और बाद में कई ऑब्जेक्ट-आधारित प्रोग्रामिंग द्वारा अपनाई गईं। ऑब्जेक्ट-आधारित और वस्तु आधारित प्रोग्रामिंग|ऑब्जेक्ट-ओरिएंटेड लैंग्वेज, जिसमें बीटा प्रोग्रामिंग भाषा, C++, D प्रोग्रामिंग लैंग्वेज, एफिल (प्रोग्रामिंग लैंग्वेज), जावा (प्रोग्रामिंग लैंग्वेज) और डिजिटल उपकरण निगम की अब निष्क्रिय सलाखें-उल्लू लैंग्वेज शामिल हैं।

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

ऐरे डेटा प्रकार और संरचना (सी प्रोग्रामिंग भाषा) को पूर्वनिर्धारित सामान्य प्रकारों के रूप में देखा जा सकता है। किसी सरणी या संरचना प्रकार का प्रत्येक उपयोग एक नए ठोस प्रकार का दृष्टांत देता है, या पिछले तात्कालिक प्रकार का पुन: उपयोग करता है। सरणी तत्व प्रकार और संरचना तत्व प्रकार पैरामीटरयुक्त प्रकार होते हैं, जिनका उपयोग संबंधित सामान्य प्रकार को तत्काल करने के लिए किया जाता है। यह सब आमतौर पर कंपाइलर में बिल्ट-इन होता है और सिंटैक्स अन्य सामान्य निर्माणों से भिन्न होता है। कुछ एक्स्टेंसिबल प्रोग्रामिंग अंतर्निर्मित और उपयोगकर्ता परिभाषित सामान्य प्रकारों को एकीकृत करने का प्रयास करते हैं।

प्रोग्रामिंग भाषाओं में सामान्यता तंत्र का एक व्यापक सर्वेक्षण इस प्रकार है। सामान्य प्रोग्रामिंग के लिए तंत्र की उपयुक्तता की तुलना करने वाले एक विशिष्ट सर्वेक्षण के लिए, देखें।

वस्तु-उन्मुख भाषाओं में

वैधानिक रूप से टाइप की गई भाषाओं में कंटेनर कक्षाएं बनाते समय, निहित प्रत्येक डेटाटाइप के लिए विशिष्ट कार्यान्वयन लिखना असुविधाजनक होता है, खासकर यदि प्रत्येक डेटाटाइप के लिए कोड वस्तुतः समान हो। उदाहरण के लिए, सी ++ में, कोड के इस डुप्लिकेशंस को क्लास टेम्पलेट को परिभाषित करके बाधित किया जा सकता है: <वाक्यविन्यास लैंग = सीपीपी> टेम्पलेट <टाइपनेम टी> वर्ग सूची {

 // वर्ग सामग्री।

};

सूची <पशु> list_of_animals; सूची <कार> list_of_cars; </वाक्यविन्यास हाइलाइट> के ऊपर, T सूची बनाते समय जो भी प्रकार निर्दिष्ट किया गया है, उसके लिए एक प्लेसहोल्डर है। ये कंटेनर-ऑफ-टाइप-टी, जिसे आमतौर पर टेम्प्लेट (प्रोग्रामिंग) कहा जाता है, एक वर्ग को विभिन्न डेटाटाइप्स के साथ पुन: उपयोग करने की अनुमति देता है जब तक कि कुछ अनुबंध जैसे कि सबटाइपिंग और हस्ताक्षर (कंप्यूटर विज्ञान) रखे जाते हैं। इस सामान्य तंत्र को बहुरूपता (कंप्यूटर विज्ञान) के साथ भ्रमित नहीं होना चाहिए, जो विनिमेय उप-वर्गों का एल्गोरिथम उपयोग है: उदाहरण के लिए, प्रकार की वस्तुओं की एक सूची Moving_Object प्रकार की वस्तुओं से युक्त Animal और Car. टेम्प्लेट का उपयोग टाइप-इंडिपेंडेंट फ़ंक्शंस के लिए भी किया जा सकता है Swap उदाहरण नीचे:

<वाक्यविन्यास लैंग = सीपीपी> // & एक संदर्भ को दर्शाता है टेम्पलेट <टाइपनेम टी> शून्य स्वैप (टी एंड ए, टी एंड बी) {// एक समान, लेकिन सुरक्षित और संभावित रूप से तेज कार्य

                       // को मानक लाइब्रेरी हेडर <उपयोगिता> में परिभाषित किया गया है
 टी अस्थायी = बी;
 बी = ए;
 ए = अस्थायी;

}

एसटीडी :: स्ट्रिंग वर्ल्ड = वर्ल्ड! ; एसटीडी :: स्ट्रिंग हैलो = हैलो; स्वैप (दुनिया, हैलो); एसटीडी :: अदालत << दुनिया << हैलो << '\n'; // आउटपुट हैलो, वर्ल्ड! . </वाक्यविन्यास हाइलाइट>

सी ++ template ऊपर प्रयुक्त निर्माण व्यापक रूप से उद्धृत किया गया है सामान्यता निर्माण के रूप में जिसने प्रोग्रामर और भाषा डिजाइनरों के बीच धारणा को लोकप्रिय बनाया और कई सामान्य प्रोग्रामिंग मुहावरों का समर्थन किया। D प्रोग्रामिंग भाषा C++ उदाहरण के आधार पर पूरी तरह से सामान्य-सक्षम टेम्प्लेट भी प्रदान करती है, लेकिन एक सरल सिंटैक्स के साथ। जावा प्रोग्रामिंग लैंग्वेज ने जावा प्लेटफॉर्म, स्टैंडर्ड एडिशन 5.0 की शुरुआत के बाद से C ++ के आधार पर सिंटैक्टिक रूप से जेनरिकिटी सुविधाएं प्रदान की हैं।

C Sharp (प्रोग्रामिंग लैंग्वेज)|C# 2.0, क्रोम प्रोग्रामिंग लैंग्वेज|ऑक्सीजीन 1.5 (जिसे क्रोम के नाम से भी जाना जाता है) और विजुअल बेसिक .NET|विजुअल बेसिक .NET 2005 में ऐसे निर्माण हैं जो .NET फ्रेमवर्क में मौजूद जेनरिक के समर्थन का लाभ उठाते हैं। Microsoft .NET Framework संस्करण 2.0 के बाद से।

अदा में जेनरिक

1977-1980 में पहली बार डिजाइन किए जाने के बाद से एडा (प्रोग्रामिंग लैंग्वेज) में जेनरिक है। मानक पुस्तकालय कई सेवाएं प्रदान करने के लिए जेनरिक का उपयोग करता है। Ada 2005 मानक लाइब्रेरी में एक व्यापक जेनेरिक कंटेनर लाइब्रेरी जोड़ता है, जो C++ के मानक टेम्पलेट लाइब्रेरी से प्रेरित था।

एक सामान्य इकाई एक पैकेज या उपप्रोग्राम है जो एक या अधिक सामान्य औपचारिक पैरामीटर लेता है।

एक सामान्य औपचारिक पैरामीटर एक मूल्य, एक चर, एक स्थिरांक, एक प्रकार, एक उपप्रोग्राम, या यहां तक ​​कि किसी अन्य, नामित, सामान्य इकाई का एक उदाहरण है। सामान्य औपचारिक प्रकारों के लिए, सिंटैक्स असतत, फ्लोटिंग-पॉइंट, फिक्स्ड-पॉइंट, एक्सेस (पॉइंटर) प्रकारों आदि के बीच अंतर करता है। कुछ औपचारिक मापदंडों में डिफ़ॉल्ट मान हो सकते हैं।

एक सामान्य इकाई को तत्काल करने के लिए, प्रोग्रामर प्रत्येक औपचारिक के लिए वास्तविक पैरामीटर पास करता है। सामान्य उदाहरण तब किसी अन्य इकाई की तरह ही व्यवहार करता है। रन टाइम (प्रोग्राम लाइफसाइकिल फेज) | रन-टाइम पर जेनेरिक यूनिट्स को इंस्टेंट करना संभव है, उदाहरण के लिए एक लूप के अंदर।

उदाहरण

एक सामान्य पैकेज की विशिष्टता:

<वाक्यविन्यास लैंग = एडीए>

सामान्य
   अधिकतम_साइज़: प्राकृतिक; - एक सामान्य औपचारिक मूल्य
   प्रकार Element_Type निजी है; - एक सामान्य औपचारिक प्रकार; किसी भी असीमित प्रकार को स्वीकार करता है
पैकेज ढेर है
   टाइप साइज_टाइप रेंज 0 है .. मैक्स_साइज;
   टाइप स्टैक सीमित निजी है;
   प्रक्रिया बनाएं (एस: आउट स्टैक;
                     इनिशियल_साइज़: साइज़_टाइप में: = मैक्स_साइज़);
   प्रक्रिया पुश (में: आउट स्टैक में; तत्व: Element_Type में);
   प्रक्रिया पॉप (से: बाहर ढेर में; तत्व: बाहर Element_Type);
   अतिप्रवाह : अपवाद;
   अंतर्प्रवाह : अपवाद;
निजी
   उपप्रकार इंडेक्स_टाइप साइज_टाइप रेंज 1 है .. मैक्स_साइज;
   टाइप वेक्टर एलिमेंट_टाइप की सरणी (इंडेक्स_टाइप रेंज <>) है;
   टाइप स्टैक (आवंटित_साइज: साइज_टाइप: = 0) रिकॉर्ड है
      शीर्ष : इंडेक्स_टाइप;
      भंडारण: वेक्टर (1 .. आवंटित_साइज);
   अंत रिकॉर्ड;
अंत ढेर;

</वाक्यविन्यास हाइलाइट>

जेनेरिक पैकेज को इंस्टेंट करना:

<वाक्यविन्यास लैंग = एडीए>

Bookmark_Type टाइप करें नया प्राकृतिक है;
-- पाठ दस्तावेज़ में एक स्थान रिकॉर्ड करता है जिसे हम संपादित कर रहे हैं

पैकेज Bookmark_Stacks नया ढेर है (Max_Size => 20,
                                       एलिमेंट_टाइप => बुकमार्क_टाइप);
- उपयोगकर्ता को किसी दस्तावेज़ में रिकॉर्ड किए गए स्थानों के बीच कूदने की अनुमति देता है

</वाक्यविन्यास हाइलाइट>

एक सामान्य पैकेज के उदाहरण का उपयोग करना:

<वाक्यविन्यास लैंग = एडीए>

टाइप करें Document_Type रिकॉर्ड है
   सामग्री: Ada.Strings.Unbounded.Unbounded_String;
   बुकमार्क : Bookmark_Stacks.Stack;
अंत रिकॉर्ड;

प्रक्रिया संपादन (Document_Name : in String) है
  दस्तावेज़ : दस्तावेज़_प्रकार;
शुरू
  - बुकमार्क के ढेर को इनिशियलाइज़ करें:
  Bookmark_Stacks.Create (S => Document.Bookmarks, Initial_Size => 10);
  - अब, फ़ाइल Document_Name खोलें और इसे इसमें पढ़ें...
अंत संपादित करें;

</वाक्यविन्यास हाइलाइट>

फायदे और सीमाएं

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

<वाक्यविन्यास लैंग = एडीए>

सामान्य
   टाइप इंडेक्स_टाइप है (<>); - एक असतत प्रकार होना चाहिए
   प्रकार Element_Type निजी है; -- कोई भी असीमित प्रकार हो सकता है
   प्रकार Array_Type Element_Type की सरणी (Index_Type श्रेणी <>) है;

</वाक्यविन्यास हाइलाइट>

इस उदाहरण में, Array_Type को Index_Type और Element_Type दोनों द्वारा प्रतिबंधित किया गया है। यूनिट को तत्काल करते समय, प्रोग्रामर को वास्तविक सरणी प्रकार पास करना होगा जो इन बाधाओं को पूरा करता है।

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

सी ++ के विपरीत, एडीए विशिष्ट सामान्य उदाहरणों की अनुमति नहीं देता है, और यह आवश्यक है कि सभी जेनरिक स्पष्ट रूप से तत्काल हों। इन नियमों के कई परिणाम होते हैं:

• कंपाइलर साझा जेनरिक को लागू कर सकता है: एक सामान्य इकाई के लिए ऑब्जेक्ट कोड को सभी उदाहरणों के बीच साझा किया जा सकता है (जब तक कि प्रोग्रामर सबप्रोग्राम को इनलाइन करने का अनुरोध नहीं करता है)। आगे के परिणाम के रूप में:
  • कोड ब्लोट की कोई संभावना नहीं है (कोड ब्लोट सी ++ में आम है और विशेष देखभाल की आवश्यकता है, जैसा कि नीचे बताया गया है)।
  • रन-टाइम के साथ-साथ संकलन समय पर जेनरिक को तुरंत चालू करना संभव है, क्योंकि नए उदाहरण के लिए कोई नया ऑब्जेक्ट कोड आवश्यक नहीं है।
  • एक सामान्य औपचारिक वस्तु के अनुरूप वास्तविक वस्तुओं को हमेशा सामान्य के अंदर गैर-स्थैतिक माना जाता है; विवरण और परिणामों के लिए wikibooks:Ada Programming/Generics#Generic फॉर्मल ऑब्जेक्ट्स विकिबूक में देखें।
• एक सामान्य के सभी उदाहरण बिल्कुल समान हैं, दूसरों द्वारा लिखे गए कार्यक्रमों की समीक्षा करना और समझना आसान है; ध्यान देने के लिए कोई विशेष मामले नहीं हैं।
• सभी तात्कालिकताएँ स्पष्ट हैं, कोई छिपी हुई तात्कालिकताएँ नहीं हैं जो कार्यक्रम को समझना मुश्किल बना सकती हैं।
• एडा टेम्प्लेट मेटाप्रोग्रामिंग की अनुमति नहीं देता है, क्योंकि यह विशेषज्ञता की अनुमति नहीं देता है।

==== सी ++ ==== में टेम्पलेट्स

Main article: Template (C++)

सी ++ सामान्य प्रोग्रामिंग तकनीकों को सक्षम करने के लिए टेम्पलेट्स का उपयोग करता है। C++ मानक पुस्तकालय में मानक टेम्पलेट पुस्तकालय या STL शामिल है जो सामान्य डेटा संरचनाओं और एल्गोरिदम के लिए टेम्पलेट का ढांचा प्रदान करता है। C++ में टेम्पलेट्स का उपयोग टेम्पलेट मेटाप्रोग्रामिंग के लिए भी किया जा सकता है, जो रन टाइम (प्रोग्राम जीवनचक्र चरण) के बजाय संकलन-समय पर कुछ कोड का पूर्व-मूल्यांकन करने का एक तरीका है। टेम्प्लेट विशेषज्ञता का उपयोग करते हुए, C++ टेम्प्लेट को ट्यूरिंग पूर्ण माना जाता है।

तकनीकी सिंहावलोकन

कई प्रकार के टेम्प्लेट हैं, सबसे आम फ़ंक्शन टेम्प्लेट और क्लास टेम्प्लेट हैं। एक फ़ंक्शन टेम्पलेट तात्कालिक होने पर आपूर्ति किए गए पैरामीटरिंग प्रकारों के आधार पर सामान्य कार्यों को बनाने के लिए एक पैटर्न है। उदाहरण के लिए, सी ++ मानक टेम्पलेट लाइब्रेरी में फ़ंक्शन टेम्पलेट होता है max(x, y) जो ऐसे फ़ंक्शन बनाता है जो या तो x या y लौटाते हैं, जो भी बड़ा हो। max() इस प्रकार परिभाषित किया जा सकता है:

<वाक्यविन्यास लैंग = सीपीपी> टेम्पलेट <टाइपनेम टी> टी मैक्स (टी एक्स, टी वाई) {

 रिटर्न एक्स <वाई? वाई : एक्स;

} </वाक्यविन्यास हाइलाइट>

इस फ़ंक्शन टेम्प्लेट की विशेषज्ञता, विशिष्ट प्रकारों के साथ तात्कालिकता, को एक साधारण फ़ंक्शन की तरह ही कहा जा सकता है:

<वाक्यविन्यास लैंग = सीपीपी> एसटीडी :: अदालत << अधिकतम (3, 7); // आउटपुट 7। </वाक्यविन्यास हाइलाइट>

कंपाइलर कॉल करने के लिए प्रयुक्त तर्कों की जांच करता है max और निर्धारित करता है कि यह एक कॉल है max(int, int). यह तब फ़ंक्शन के एक संस्करण को तुरंत चालू करता है जहां पैरामीटरिंग प्रकार होता है T है int, निम्नलिखित फ़ंक्शन के समतुल्य बनाना:

<वाक्यविन्यास लैंग = सीपीपी> इंट मैक्स (इंट एक्स, इंट वाई) {

 रिटर्न एक्स <वाई? वाई : एक्स;

} </वाक्यविन्यास हाइलाइट>

यह काम करता है कि क्या तर्क x और y पूर्णांक, तार, या कोई अन्य प्रकार जिसके लिए अभिव्यक्ति है x < y समझदार है, या अधिक विशेष रूप से, किसी भी प्रकार के लिए जिसके लिए operator< परिभाषित किया गया। उपयोग किए जा सकने वाले प्रकारों के सेट के लिए सामान्य वंशानुक्रम की आवश्यकता नहीं है, और इसलिए यह डक टाइपिंग # टेम्प्लेट या सामान्य प्रकारों के समान है। कस्टम डेटा प्रकार को परिभाषित करने वाला प्रोग्राम ऑपरेटर ओवरलोडिंग का अर्थ परिभाषित करने के लिए उपयोग कर सकता है < उस प्रकार के लिए, इस प्रकार इसके उपयोग की अनुमति देता है max() समारोह टेम्पलेट। हालांकि यह इस पृथक उदाहरण में एक मामूली लाभ प्रतीत हो सकता है, एसटीएल जैसे व्यापक पुस्तकालय के संदर्भ में यह प्रोग्रामर को नए डेटा प्रकार के लिए व्यापक कार्यक्षमता प्राप्त करने की अनुमति देता है, केवल इसके लिए कुछ ऑपरेटरों को परिभाषित करके। केवल परिभाषित करना < एक प्रकार को मानक के साथ उपयोग करने की अनुमति देता है sort(), stable_sort(), और binary_search() एल्गोरिदम या डेटा संरचनाओं जैसे अंदर रखा जाना sets, हीप (प्रोग्रामिंग) s, और साहचर्य सरणियाँ।

संकलन समय पर सी ++ टेम्पलेट्स पूरी तरह से सुरक्षा प्रकार हैं। एक प्रदर्शन के रूप में, मानक प्रकार complex परिभाषित नहीं करता < ऑपरेटर, क्योंकि सम्मिश्र संख्याओं पर कोई सख्त आदेश नहीं है। इसलिए, max(x, y) संकलन त्रुटि के साथ विफल हो जाएगा, यदि x और y हैं complex मान। इसी तरह, अन्य टेम्प्लेट जो भरोसा करते हैं < पर लागू नहीं किया जा सकता complex डेटा जब तक एक तुलना (फ़ंक्शन या फ़ंक्शन के रूप में) प्रदान नहीं की जाती है। उदा.: ए complex a के लिए कुंजी के रूप में उपयोग नहीं किया जा सकता है map जब तक कोई तुलना प्रदान नहीं की जाती है। दुर्भाग्य से, संकलक ऐतिहासिक रूप से इस प्रकार की त्रुटि के लिए कुछ गूढ़, लंबे और अनुपयोगी त्रुटि संदेश उत्पन्न करते हैं। यह सुनिश्चित करना कि एक निश्चित वस्तु एक प्रोटोकॉल (कंप्यूटर विज्ञान) का पालन करती है, इस मुद्दे को कम कर सकती है। उपयोग की जाने वाली भाषाएँ compare के बजाय < भी उपयोग कर सकते हैं complex कुंजियों के रूप में मान।

एक अन्य प्रकार का टेम्प्लेट, एक क्लास टेम्प्लेट, उसी अवधारणा को कक्षाओं तक बढ़ाता है। एक वर्ग टेम्पलेट विशेषज्ञता एक वर्ग है। सामान्य कंटेनर बनाने के लिए अक्सर क्लास टेम्प्लेट का उपयोग किया जाता है। उदाहरण के लिए, एसटीएल के पास एक लिंक्ड सूची कंटेनर है। पूर्णांकों की एक लिंक्ड सूची बनाने के लिए, कोई लिखता है list<int>. तार की एक सूची निरूपित है list<string>. ए list इसके साथ जुड़े मानक कार्यों का एक सेट है, जो किसी भी संगत पैरामीटर प्रकार के लिए काम करता है।

टेम्पलेट विशेषज्ञता

सी++ के टेम्पलेट्स की एक शक्तिशाली विशेषता टेम्पलेट विशेषज्ञता है। यह तात्कालिक होने वाले पैरामीटरयुक्त प्रकार की कुछ विशेषताओं के आधार पर वैकल्पिक कार्यान्वयन प्रदान करने की अनुमति देता है। खाका विशेषज्ञता के दो उद्देश्य हैं: अनुकूलन के कुछ रूपों की अनुमति देना, और कोड ब्लोट को कम करना।

उदाहरण के लिए, ए पर विचार करें sort() टेम्पलेट समारोह। इस तरह के फ़ंक्शन द्वारा की जाने वाली प्राथमिक गतिविधियों में से एक कंटेनर की दो स्थितियों में मूल्यों की अदला-बदली या विनिमय करना है। यदि मान बड़े हैं (उनमें से प्रत्येक को संग्रहीत करने के लिए बाइट्स की संख्या के संदर्भ में), तो वस्तुओं के लिए पॉइंटर्स की एक अलग सूची बनाना, उन पॉइंटर्स को क्रमबद्ध करना और फिर अंतिम क्रमबद्ध अनुक्रम बनाना अक्सर तेज़ होता है . यदि मान काफी छोटे हैं, लेकिन आमतौर पर आवश्यकतानुसार मूल्यों को केवल इन-प्लेस स्वैप करना सबसे तेज़ होता है। इसके अलावा, यदि पैरामिट्रीकृत प्रकार पहले से ही कुछ सूचक-प्रकार का है, तो एक अलग सूचक सरणी बनाने की कोई आवश्यकता नहीं है। टेम्पलेट विशेषज्ञता टेम्पलेट निर्माता को अलग-अलग कार्यान्वयन लिखने और उन विशेषताओं को निर्दिष्ट करने की अनुमति देती है जो उपयोग किए जाने वाले प्रत्येक कार्यान्वयन के लिए पैरामीटरयुक्त प्रकार (ओं) में होनी चाहिए।

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

फायदे और नुकसान

टेम्प्लेट के कुछ उपयोग, जैसे कि max() फ़ंक्शन, पहले फ़ंक्शन-जैसे पूर्वप्रक्रमक मैक्रो (कंप्यूटर विज्ञान) (सी (प्रोग्रामिंग भाषा) की विरासत) द्वारा भरे गए थे। उदाहरण के लिए, यहाँ इस तरह के मैक्रो का संभावित कार्यान्वयन है:

<वाक्यविन्यास लैंग = सीपीपी>

1. परिभाषित अधिकतम (ए, बी) ((ए) <(बी)? (बी): (ए))

</वाक्यविन्यास हाइलाइट>

मैक्रोज़ का विस्तार (कॉपी पेस्ट) प्रीप्रोसेसर द्वारा किया जाता है, उचित संकलन से पहले; टेम्पलेट वास्तविक वास्तविक कार्य हैं। मैक्रोज़ हमेशा इनलाइन विस्तारित होते हैं; जब कंपाइलर इसे उचित समझे तो टेम्प्लेट इनलाइन समारोह भी हो सकते हैं।

हालाँकि, इन उद्देश्यों के लिए टेम्प्लेट को आमतौर पर मैक्रोज़ पर सुधार माना जाता है। टेम्प्लेट टाइप-सुरक्षित हैं। टेम्प्लेट कोड में पाई जाने वाली कुछ सामान्य त्रुटियों से बचते हैं जो फ़ंक्शन-जैसे मैक्रोज़ का भारी उपयोग करती हैं, जैसे दो बार साइड इफेक्ट वाले मापदंडों का मूल्यांकन करना। शायद सबसे महत्वपूर्ण बात यह है कि टेम्प्लेट मैक्रोज़ की तुलना में बहुत बड़ी समस्याओं पर लागू होने के लिए डिज़ाइन किए गए थे।

टेम्प्लेट के उपयोग में चार प्राथमिक कमियां हैं: समर्थित विशेषताएं, कंपाइलर समर्थन, खराब त्रुटि संदेश (आमतौर पर पूर्व C++20 SFINAE के साथ), और कोड ब्लोट:

1. C++ में टेम्प्लेट में कई विशेषताओं का अभाव होता है, जिससे उन्हें लागू करना और सीधे तरीके से उनका उपयोग करना अक्सर असंभव हो जाता है। इसके बजाय प्रोग्रामर को जटिल ट्रिक्स पर निर्भर रहना पड़ता है जिससे फूला हुआ, समझने में कठिन और कोड को बनाए रखने में कठिनाई होती है। C++ मानकों में वर्तमान विकास इन तरकीबों का भारी उपयोग करके और उन पर टेम्प्लेट के लिए या उन्हें ध्यान में रखते हुए बहुत सी नई सुविधाओं का निर्माण करके इस समस्या को बढ़ा देता है।
2. कई कंपाइलरों को ऐतिहासिक रूप से टेम्प्लेट के लिए खराब समर्थन था, इस प्रकार टेम्प्लेट के उपयोग से कोड कुछ कम पोर्टेबल हो सकता था। समर्थन तब भी खराब हो सकता है जब एक C++ कंपाइलर का उपयोग एक ऐसे लिंकर (कंप्यूटिंग) के साथ किया जा रहा है जो C++-जागरूक नहीं है, या लाइब्रेरी (कंप्यूटर विज्ञान)#साझा लाइब्रेरी सीमाओं में टेम्पलेट का उपयोग करने का प्रयास करते समय।
3. SFINAE का उपयोग करने वाले कोड में त्रुटियों का पता चलने पर कंपाइलर भ्रामक, लंबे और कभी-कभी अनुपयोगी त्रुटि संदेश उत्पन्न कर सकते हैं। इससे टेम्प्लेट को विकसित करना मुश्किल हो सकता है।
4. अंत में, टेम्प्लेट के उपयोग के लिए कंपाइलर को इसके साथ उपयोग किए जाने वाले प्रकार के मापदंडों के प्रत्येक क्रमपरिवर्तन के लिए टेम्प्लेटेड क्लास या फ़ंक्शन का एक अलग उदाहरण उत्पन्न करने की आवश्यकता होती है। (यह आवश्यक है क्योंकि C++ में सभी प्रकार समान आकार के नहीं होते हैं, और डेटा फ़ील्ड्स के आकार वर्ग के काम करने के तरीके के लिए महत्वपूर्ण होते हैं।) इसलिए टेम्प्लेट के अंधाधुंध उपयोग से कोड ब्लोट हो सकता है, जिसके परिणामस्वरूप अत्यधिक बड़े निष्पादन योग्य होते हैं। हालाँकि, टेम्पलेट विशेषज्ञता और व्युत्पत्ति का विवेकपूर्ण उपयोग कुछ मामलों में ऐसे कोड ब्लोट को नाटकीय रूप से कम कर सकता है:

So, can derivation be used to reduce the problem of code replicated because templates are used? This would involve deriving a template from an ordinary class. This technique proved successful in curbing code bloat in real use. People who do not use a technique like this have found that replicated code can cost megabytes of code space even in moderate size programs.

— Bjarne Stroustrup, The Design and Evolution of C++, 1994

टेम्प्लेट द्वारा उत्पन्न अतिरिक्त तात्कालिकता भी कुछ डिबगर्स को टेम्प्लेट के साथ शानदार ढंग से काम करने में कठिनाई का कारण बन सकती है। उदाहरण के लिए, एक स्रोत फ़ाइल से एक टेम्पलेट के भीतर एक डिबग ब्रेकप्वाइंट सेट करना या तो वांछित वास्तविक इंस्टेंटेशन में ब्रेकपॉइंट सेट करने से चूक सकता है या हर उस जगह पर एक ब्रेकपॉइंट सेट कर सकता है जहां टेम्प्लेट को इंस्टेंट किया जाता है।

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

==== डी == में टेम्पलेट्स

D प्रोग्रामिंग भाषा C++ पर डिज़ाइन के आधार पर टेम्पलेट्स का समर्थन करती है। अधिकांश सी ++ टेम्पलेट मुहावरे बिना किसी बदलाव के डी तक पहुंच जाएंगे, लेकिन डी कुछ अतिरिक्त कार्यक्षमता जोड़ता है:

• डी में टेम्पलेट पैरामीटर केवल प्रकार और आदिम मूल्यों तक ही सीमित नहीं हैं (जैसा कि यह सी ++ 20 से पहले सी ++ में था), लेकिन मनमाना संकलन-समय मान (जैसे स्ट्रिंग्स और स्ट्रक्चर अक्षर) और मनमाने ढंग से पहचानकर्ताओं के लिए उपनाम भी अनुमति देते हैं, अन्य टेम्प्लेट या टेम्प्लेट इंस्टेंटेशन सहित।
• खाका बाधाओं और static if बयान क्रमशः सी ++ की अवधारणाओं (सी ++) | सी ++ अवधारणाओं और के लिए एक विकल्प प्रदान करते हैं if constexpr.
• is(...) ई> अभिव्यक्ति सट्टा तात्कालिकता को संकलन समय पर किसी वस्तु के लक्षणों को सत्यापित करने की अनुमति देती है।
• auto ई> कीवर्ड और typeof अभिव्यक्ति परिवर्तनीय घोषणाओं और फ़ंक्शन रिटर्न मानों के लिए प्रकार के अनुमान की अनुमति देती है, जो बदले में वोल्डेमॉर्ट प्रकार (ऐसे प्रकार जिनके पास वैश्विक नाम नहीं है) की अनुमति देता है।

D में टेम्प्लेट C++ की तुलना में एक अलग सिंटैक्स का उपयोग करते हैं: जबकि C++ टेम्प्लेट में पैरामीटर कोणीय कोष्ठक में लपेटे जाते हैं (Template<param1, param2>), D विस्मयादिबोधक चिह्न और कोष्ठक का उपयोग करता है: Template!(param1, param2). यह तुलना ऑपरेटरों के साथ अस्पष्टता के कारण टेम्पलेट (C++)#लाभ और हानि|C++ पार्सिंग कठिनाइयों से बचा जाता है। यदि केवल एक पैरामीटर है, तो कोष्ठकों को छोड़ा जा सकता है।

परंपरागत रूप से, डी उपरोक्त सुविधाओं को विशेषता-आधारित जेनेरिक प्रोग्रामिंग का उपयोग करके संकलन-समय बहुरूपता प्रदान करने के लिए जोड़ती है। उदाहरण के लिए, एक इनपुट रेंज (कंप्यूटर प्रोग्रामिंग) # रेंज को इटरेटर के विकल्प के रूप में किसी भी प्रकार के रूप में परिभाषित किया गया है जो द्वारा किए गए चेक को संतुष्ट करता है isInputRange, जिसे इस प्रकार परिभाषित किया गया है:

<वाक्यविन्यास प्रकाश लैंग = डी> टेम्पलेट isInputRange (आर) {

   एनम बूल isInputRange = है (टाइपोफ (
   (इनआउट इंट = 0)
   {
       आर आर = आर.इनिट; // एक रेंज ऑब्जेक्ट को परिभाषित कर सकता है
       if (r.empty) {} // खाली के लिए परीक्षण कर सकता है
       आर पॉपफ्रंट (); // पॉपफ्रंट () का आह्वान कर सकते हैं
       ऑटो एच = आर सामने; // सीमा के सामने प्राप्त कर सकते हैं
   }));

} </वाक्यविन्यास हाइलाइट>

एक फ़ंक्शन जो केवल इनपुट रेंज स्वीकार करता है, फिर उपरोक्त टेम्पलेट का उपयोग टेम्पलेट बाधा में कर सकता है:

<वाक्यविन्यास प्रकाश लैंग = डी> ऑटो मज़ा (रेंज) (रेंज रेंज)

   अगर (isInputRange! रेंज)

{

   // ...

} </वाक्यविन्यास हाइलाइट>

कोड जनरेशन

टेम्प्लेट मेटाप्रोग्रामिंग के अलावा, डी संकलन-समय कोड जनरेशन को सक्षम करने के लिए कई सुविधाएँ भी प्रदान करता है:

• import e> व्यंजक डिस्क से किसी फ़ाइल को पढ़ने और उसकी सामग्री को एक स्ट्रिंग व्यंजक के रूप में उपयोग करने की अनुमति देता है।
• संकलन-समय प्रतिबिंब संकलन के दौरान घोषणाओं और उनके सदस्यों की गणना और निरीक्षण करने की अनुमति देता है।
• उपयोगकर्ता-परिभाषित विशेषता (कंप्यूटिंग) उपयोगकर्ताओं को घोषणाओं के लिए मनमाना पहचानकर्ता संलग्न करने की अनुमति देती है, जिसे संकलन-समय प्रतिबिंब का उपयोग करके गणना की जा सकती है।
• संकलन-समय फ़ंक्शन निष्पादन | कंपाइल-टाइम फंक्शन एक्ज़ीक्यूशन (CTFE) संकलन के दौरान व्याख्या करने के लिए D (सुरक्षित संचालन के लिए प्रतिबंधित) के एक सबसेट की अनुमति देता है।
• स्ट्रिंग मिश्रण एक स्ट्रिंग अभिव्यक्ति की सामग्री को डी कोड के रूप में मूल्यांकन और संकलित करने की अनुमति देता है जो कार्यक्रम का हिस्सा बन जाता है।

उपरोक्त संयोजन मौजूदा घोषणाओं के आधार पर कोड उत्पन्न करने की अनुमति देता है। उदाहरण के लिए, डी क्रमांकन ढांचे एक प्रकार के सदस्यों की गणना कर सकते हैं और प्रत्येक क्रमबद्ध प्रकार के लिए विशेष कार्य उत्पन्न कर सकते हैं क्रमांकन और अक्रमांकन करने के लिए। उपयोक्ता-परिभाषित विशेषताएँ क्रमांकन नियमों को और इंगित कर सकती हैं। import e> अभिव्यक्ति और संकलन-समय फ़ंक्शन निष्पादन भी डोमेन-विशिष्ट भाषाओं को कुशलतापूर्वक कार्यान्वित करने की अनुमति देता है। उदाहरण के लिए, एक फ़ंक्शन दिया गया है जो एक HTML टेम्पलेट वाली स्ट्रिंग लेता है और समकक्ष डी स्रोत कोड देता है, इसे निम्न तरीके से उपयोग करना संभव है:

<वाक्यविन्यास प्रकाश लैंग = डी> // example.htt की सामग्री को एक स्ट्रिंग मेनिफेस्ट स्थिरांक के रूप में आयात करें। एनम एचटीएमएल टेम्पलेट = आयात (उदाहरण। एचटीटी);

// HTML टेम्प्लेट को D कोड में ट्रांसपाइल करें। एनम htmlDCode = htmlTemplateToD (htmlTemplate);

// htmlDCode की सामग्री को D कोड के रूप में पेस्ट करें। मिक्सिन (htmlDCode); </वाक्यविन्यास हाइलाइट>

एफिल में उदारता

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

बुनियादी/अप्रतिबंधित उदारता

सामान्य वर्गों को उनके वर्ग के नाम और एक या अधिक औपचारिक सामान्य मापदंडों की सूची के साथ घोषित किया जाता है। निम्नलिखित कोड में, वर्ग LIST में एक औपचारिक सामान्य पैरामीटर G है

<वाक्यविन्यास लैंग = एफिल> कक्षा

   सूची [जी]
           ...

सुविधा - पहुंच

   आइटम: जी
           - आइटम वर्तमान में कर्सर द्वारा इंगित किया गया है
           ...

सुविधा - तत्व परिवर्तन

   डाल (new_item: जी)
           - सूची के अंत में 'new_item' जोड़ें
           ...

</वाक्यविन्यास हाइलाइट>

औपचारिक जेनेरिक पैरामीटर मनमाना वर्ग नामों के लिए प्लेसहोल्डर हैं जो जेनेरिक वर्ग की घोषणा होने पर प्रदान किए जाएंगे, जैसा कि नीचे दो सामान्य व्युत्पन्नों में दिखाया गया है, जहां ACCOUNT और DEPOSIT अन्य वर्ग के नाम हैं। ACCOUNT और DEPOSIT को वास्तविक सामान्य पैरामीटर माना जाता है क्योंकि वे वास्तविक में G के स्थानापन्न करने के लिए वास्तविक वर्ग नाम प्रदान करते हैं उपयोग।

<वाक्यविन्यास लैंग = एफिल>

   list_of_accounts: सूची [खाता]
           - खाता सूची

   list_of_deposits: सूची [जमा]
           - जमा सूची

</वाक्यविन्यास हाइलाइट>

एफिल प्रकार प्रणाली के भीतर, हालांकि वर्ग LIST [G] को एक वर्ग माना जाता है, इसे एक प्रकार नहीं माना जाता है। हालांकि, LIST [G] की एक सामान्य व्युत्पत्ति जैसे LIST [ACCOUNT] को एक प्रकार माना जाता है।

विवश उदारता

ऊपर दिखाए गए सूची वर्ग के लिए, G के लिए प्रतिस्थापित एक वास्तविक सामान्य पैरामीटर कोई अन्य उपलब्ध वर्ग हो सकता है। क्लास के उस सेट को प्रतिबंधित करने के लिए जिसमें से वैध वास्तविक जेनेरिक पैरामीटर चुने जा सकते हैं, एक सामान्य बाधा निर्दिष्ट की जा सकती है। नीचे वर्ग SORTED_LIST की घोषणा में, सामान्य बाधा निर्धारित करती है कि कोई भी मान्य वास्तविक सामान्य पैरामीटर एक ऐसा वर्ग होगा जो वर्ग COMPARABLE से प्राप्त होता है। सामान्य बाधा यह सुनिश्चित करती है कि SORTED_LIST के तत्वों को वास्तव में क्रमबद्ध किया जा सकता है।

<वाक्यविन्यास लैंग = एफिल> कक्षा

   SORTED_LIST [जी -> तुलनीय]

</वाक्यविन्यास हाइलाइट>

जावा में जेनरिक

Main article: Generics in Java

J2SE 5.0 के भाग के रूप में 2004 में जावा (प्रोग्रामिंग भाषा) में जेनरिक, या कंटेनर-ऑफ-टाइप-टी के लिए समर्थन जोड़ा गया था। जावा में, जेनरिक केवल टाइप शुद्धता के लिए संकलन समय पर चेक किए जाते हैं। पुराने जेवीएम कार्यान्वयन के साथ संगतता बनाए रखने के लिए सामान्य प्रकार की जानकारी को मिटाना टाइप करें नामक प्रक्रिया के माध्यम से हटा दिया जाता है, जिससे यह रनटाइम पर अनुपलब्ध हो जाता है। उदाहरण के लिए, ए List<String> कच्चे प्रकार में परिवर्तित हो जाता है List. कंपाइलर तत्वों को परिवर्तित करने के लिए प्रकार रूपांतरण सम्मिलित करता है String टाइप करें जब उन्हें सूची से पुनर्प्राप्त किया जाता है, अन्य कार्यान्वयन जैसे सी ++ टेम्पलेट्स की तुलना में प्रदर्शन को कम करता है।

.NET में उदारता [C#, VB.NET]

जेनरिक को .NET Framework#.NET Framework 2.0|.NET Framework 2.0 के हिस्से के रूप में नवंबर 2005 में जोड़ा गया था, जो 1999 में शुरू हुए Microsoft अनुसंधान के एक शोध प्रोटोटाइप पर आधारित था। हालांकि जावा में जेनरिक के समान, .NET जेनरिक टाइप इरेज़र लागू नहीं करते हैं, लेकिन रीफिकेशन (कंप्यूटर साइंस) का उपयोग करके रनटाइम में जेनरिक को प्रथम श्रेणी तंत्र के रूप में लागू करते हैं। यह डिज़ाइन विकल्प अतिरिक्त कार्यक्षमता प्रदान करता है, जैसे सामान्य प्रकारों के संरक्षण के साथ प्रतिबिंब (कंप्यूटर विज्ञान) की अनुमति देना, साथ ही मिटाने की कुछ सीमाओं को कम करना (जैसे सामान्य सरणी बनाने में असमर्थ होना)। इसका यह भी अर्थ है कि रनटाइम प्रकार रूपांतरण और सामान्य रूप से महंगे बॉक्सिंग (कंप्यूटर विज्ञान) से कोई प्रदर्शन प्रभावित नहीं होता है। जब आदिम और मूल्य प्रकार सामान्य तर्कों के रूप में उपयोग किए जाते हैं, तो उन्हें कुशल सामान्य संग्रह वर्ग और विधियों की अनुमति देने के लिए विशेष कार्यान्वयन प्राप्त होते हैं। C++ और Java की तरह, नेस्टेड जेनेरिक प्रकार जैसे Dictionary<string, List<int>> वैध प्रकार हैं, हालांकि कोड विश्लेषण डिजाइन नियमों में सदस्य हस्ताक्षरों के खिलाफ सलाह दी जाती है। .NET .NET का उपयोग करके सामान्य प्रकार की बाधाओं की छह किस्मों की अनुमति देता है where कीवर्ड में सामान्य प्रकार को मूल्य प्रकार, वर्ग होने, निर्माता होने और इंटरफेस को लागू करने के लिए प्रतिबंधित करना शामिल है। नीचे एक इंटरफ़ेस बाधा के साथ एक उदाहरण है:

<वाक्यविन्यास लैंग = सीशार्प लाइन = 1> सिस्टम का उपयोग करना;

वर्ग नमूना {

   स्थिर शून्य मुख्य ()
   {
       int [] सरणी = {0, 1, 2, 3};
       MakeAtLeast<int>(सरणी, 2); // सरणी को {2, 2, 2, 3} में बदलें
       foreach (सरणी में int i)
           कंसोल.राइटलाइन (i); // प्रिंट परिणाम।
       कंसोल। रीडकी (सत्य);
   }

   स्थैतिक शून्य MakeAtLeast <टी> (टी [] सूची, टी सबसे कम) जहां टी: आईसीओम्परेबल <टी>
   {
       for (int i = 0; i <list.Length; i++)
           अगर (सूची [i]। तुलना करने के लिए (निम्नतम) <0)
               सूची [i] = निम्नतम;
   }

} </वाक्यविन्यास हाइलाइट> MakeAtLeast() ई> विधि सामान्य प्रकार के तत्वों के साथ सरणियों पर संचालन की अनुमति देती है T. विधि के प्रकार की बाधा इंगित करती है कि विधि किसी भी प्रकार पर लागू होती है T जो जेनेरिक लागू करता है IComparable<T> इंटरफेस। यह एक संकलन समय त्रुटि सुनिश्चित करता है, यदि विधि को कॉल किया जाता है यदि प्रकार तुलना का समर्थन नहीं करता है। इंटरफ़ेस सामान्य विधि प्रदान करता है CompareTo(T).

उपरोक्त विधि सामान्य प्रकार के बिना भी लिखी जा सकती है, केवल गैर-जेनेरिक का उपयोग करके Array प्रकार। हालाँकि, चूंकि सरणियाँ सहप्रसरण और प्रतिप्रसरण (कंप्यूटर विज्ञान) हैं, इसलिए कास्टिंग टाइप सुरक्षित नहीं होगी, और संकलक कुछ संभावित त्रुटियों को खोजने में असमर्थ होगा जो अन्यथा सामान्य प्रकारों का उपयोग करते समय पकड़े जाएंगे। इसके अलावा, विधि को सरणी आइटम को एक्सेस करने की आवश्यकता होगी objectइसके बजाय, और दो तत्वों की तुलना करने के लिए प्रकार रूपांतरण की आवश्यकता होगी। (मूल्य प्रकार जैसे प्रकार के लिए int इसके लिए एक बॉक्सिंग (कंप्यूटर विज्ञान) रूपांतरण की आवश्यकता होती है, हालांकि इसे Comparer<T> क्लास, जैसा कि मानक संग्रह कक्षाओं में किया जाता है।)

एक सामान्य .NET वर्ग में स्थिर सदस्यों का एक उल्लेखनीय व्यवहार प्रति रन-टाइम प्रकार के लिए स्थिर सदस्य तात्कालिकता है (नीचे उदाहरण देखें)।

<वाक्यविन्यास प्रकाश लैंग = सीशार्प>

   // एक सामान्य वर्ग
   पब्लिक क्लास जेनटेस्ट <टी>
   {
       // एक स्थिर चर - प्रतिबिंब पर प्रत्येक प्रकार के लिए बनाया जाएगा
       स्टेटिक काउंटेड इंस्टेंस वनपरटाइप = नया काउंटेड इंस्टेंस ();

       // एक डेटा सदस्य
       निजी टी एमटी;

       // सरल कंस्ट्रक्टर
       पब्लिक जेनटेस्ट (टी पीटी)
       {
           एमटी = पीटी;
       }
   }

   //एक कक्षा
   पब्लिक क्लास काउंटेड इंस्टेंस
   {
       // स्टेटिक वैरिएबल - यह प्रति उदाहरण एक बार बढ़ाया जाएगा
       सार्वजनिक स्थैतिक इंट काउंटर;

       // सरल कंस्ट्रक्टर
       पब्लिक काउंटेड इंस्टेंसेस ()
       {
           // ऑब्जेक्ट इंस्टेंटेशन के दौरान काउंटर को एक से बढ़ाएं
           काउंटेड इंस्टेंस। काउंटर ++;
       }
   }

 // मुख्य कोड प्रवेश बिंदु
 // निष्पादन के अंत में, काउंटेड इंस्टेंस। काउंटर = 2
 GenTest<int> g1 = new GenTest<int>(1);
 GenTest<int> g11 = new GenTest<int>(11);
 GenTest<int> g111 = new GenTest<int>(111);
 GenTest<double> g2 = new GenTest<double>(1.0);

</वाक्यविन्यास हाइलाइट>

डेल्फी में उदारता

डेल्फी (प्रोग्रामिंग भाषा) | डेल्फी की ऑब्जेक्ट पास्कल बोली ने डेल्फी 2007 रिलीज में जेनरिक का अधिग्रहण किया, शुरू में केवल (अब बंद) .NET कंपाइलर के साथ डेल्फी 2009 रिलीज में मूल कोड में जोड़े जाने से पहले। डेल्फी जेनरिक के शब्दार्थ और क्षमताएं बड़े पैमाने पर .NET 2.0 में जेनरिक के पास मौजूद हैं, हालांकि कार्यान्वयन आवश्यकता से काफी अलग है। ऊपर दिखाए गए पहले C# उदाहरण का कमोबेश सीधा अनुवाद यहां दिया गया है:

<वाक्यविन्यास लैंग = डेल्फी> कार्यक्रम का नमूना;

{$APPTYPE कंसोल}

उपयोग

 जेनरिक। चूक; // IComparer <> के लिए

प्रकार

 टुटिल्स = क्लास
   वर्ग प्रक्रिया MakeAtLeast<T>(Arr: TArray<T>; const Lowest: T;
     तुलनाकर्ता: IComparer<T>); अधिभार;
   क्लास प्रक्रिया MakeAtLeast<T>(Arr: TArray<T>; const Lowest: T); अधिभार;
 अंत;

वर्ग प्रक्रिया TUtils.MakeAtLeast<T>(Arr: TArray<T>; const Lowest: T;

 तुलनाकर्ता: IComparer<T>);

वर

 मैं: पूर्णांक;

शुरू

 अगर तुलनाकर्ता = शून्य तो तुलनाकर्ता: = टीकंपैयर <टी>। डिफ़ॉल्ट;
 for I := Low(Arr) से High(Arr) करते हैं
   अगर Comparer.Compare(Arr[I], Lowest) < 0 तब
     अर्र [मैं] : = निम्नतम;

अंत;

वर्ग प्रक्रिया TUtils.MakeAtLeast<T>(Arr: TArray<T>; const Lowest: T); शुरू

 MakeAtLeast<T>(Arr, Lowest, nil);

अंत;

वर

 चींटियाँ: TArray <पूर्णांक>;
 मान: पूर्णांक;

शुरू

 इनट्स := TArray<पूर्णांक>.Create(0, 1, 2, 3);
 TUtils.MakeAtLeast<पूर्णांक>(Ints, 2);
 मूल्य के लिए ints do
   एलएन (मान) लिखें;
 पढ़ेंLn;

अंत। </वाक्यविन्यास हाइलाइट>

सी # के साथ, विधियों के साथ-साथ पूरे प्रकार में एक या अधिक प्रकार के पैरामीटर हो सकते हैं। उदाहरण में, TArray एक सामान्य प्रकार है (भाषा द्वारा परिभाषित) और MakeAtLeast एक सामान्य विधि है। उपलब्ध बाधाएँ C # में उपलब्ध बाधाओं के समान हैं: कोई भी मान प्रकार, कोई भी वर्ग, एक विशिष्ट वर्ग या इंटरफ़ेस, और एक पैरामीटर रहित कंस्ट्रक्टर वाला वर्ग। एकाधिक बाधाएं एक योगात्मक संघ के रूप में कार्य करती हैं।

फ़्री पास्कल में उदारता

नि: शुल्क पास्कल ने डेल्फी से पहले और विभिन्न सिंटैक्स और शब्दार्थ के साथ जेनरिक को लागू किया। हालांकि, एफपीसी संस्करण 2.6.0 के बाद से, {$ मोड डेल्फी} भाषा मोड का उपयोग करते समय डेल्फी-शैली सिंटैक्स उपलब्ध है। इस प्रकार, नि: शुल्क पास्कल प्रोग्रामर जेनरिक का उपयोग किसी भी शैली में कर सकते हैं जो वे पसंद करते हैं।

डेल्फी और फ्री पास्कल उदाहरण: <वाक्यविन्यास लैंग = डेल्फी> // डेल्फी शैली यूनिट ए;

{$ifdef fpc}

 {$ मोड डेल्फी}

{$endif}

इंटरफेस

प्रकार

 टीजीनेरिक क्लास <टी> = क्लास
   समारोह फू (स्थिरांक AValue: टी): टी;
 अंत;

कार्यान्वयन

समारोह TGenericClass<T>.Foo(स्थिरांक AValue: T): T; शुरू

 परिणाम := एवैल्यू + एवैल्यू;

अंत;

अंत।

// फ्री पास्कल का ओब्जेएफपीसी स्टाइल यूनिट बी;

{$ifdef fpc}

 {$ मोड ओबीजेएफपीसी}

{$endif}

इंटरफेस

प्रकार

 जेनेरिक टीजीनेरिक क्लास <टी> = क्लास
   समारोह फू (स्थिरांक AValue: टी): टी;
 अंत;

कार्यान्वयन

समारोह TGenericClass.Foo (स्थिरांक AValue: टी): टी; शुरू

 परिणाम := एवैल्यू + एवैल्यू;

अंत;

अंत।

// उदाहरण उपयोग, डेल्फी शैली प्रोग्राम टेस्टजेनडेल्फी;

{$ifdef fpc}

 {$ मोड डेल्फी}

{$endif}

उपयोग

 ए, बी;

वर

 GC1: A.TGenericClass<पूर्णांक>;
 GC2: B.TGenericClass<String>;

शुरू

 GC1 := A.TGenericClass<पूर्णांक>.Create;
 GC2 := B.TGenericClass<String>.Create;
 राइटएलएन (जीसी1.फू (100)); // 200
 WriteLn (GC2.Foo ('हैलो')); // हैलो हैलो
 जीसी1.फ्री;
 जीसी2.फ्री;

अंत।

// उदाहरण उपयोग, ओबीजेएफपीसी शैली प्रोग्राम टेस्टजेनडेल्फी;

{$ifdef fpc}

 {$ मोड ओबीजेएफपीसी}

{$endif}

उपयोग

 ए, बी;

// ओबीजेएफपीसी में आवश्यक है प्रकार

 TAGenericClassInt = विशेषज्ञ A.TGenericClass<पूर्णांक>;
 TBGenericClassString = B.TGenericClass<String>;

वर

 GC1: TAGenericClassInt;
 जीसी2: टीबीजेनरिकक्लासस्ट्रिंग;

शुरू

 GC1 := TAGenericClassInt.Create;
 GC2 := TBGenericClassString.Create;
 राइटएलएन (जीसी1.फू (100)); // 200
 WriteLn (GC2.Foo ('हैलो')); // हैलो हैलो
 जीसी1.फ्री;
 जीसी2.फ्री;

अंत। </वाक्यविन्यास हाइलाइट>

कार्यात्मक भाषाएं

हास्केल में उदारता

हास्केल (प्रोग्रामिंग लैंग्वेज) का वर्ग टाइप करें मैकेनिज्म जेनेरिक प्रोग्रामिंग को सपोर्ट करता है। हास्केल में पूर्वनिर्धारित प्रकार की छह कक्षाएं (सहित Eq, वे प्रकार जिनकी समानता के लिए तुलना की जा सकती है, और Show, वे प्रकार जिनके मान स्ट्रिंग्स के रूप में प्रस्तुत किए जा सकते हैं) में व्युत्पन्न उदाहरणों का समर्थन करने की विशेष संपत्ति होती है। इसका मतलब यह है कि एक नए प्रकार को परिभाषित करने वाला एक प्रोग्रामर यह बता सकता है कि यह प्रकार इन विशेष प्रकार के वर्गों में से एक का एक उदाहरण है, बिना क्लास के तरीकों के कार्यान्वयन प्रदान किए बिना, जैसा कि क्लास इंस्टेंसेस की घोषणा करते समय आमतौर पर आवश्यक होता है। प्रकार की संरचना के आधार पर सभी आवश्यक विधियों को व्युत्पन्न किया जाएगा - अर्थात स्वचालित रूप से निर्मित किया जाएगा। उदाहरण के लिए, एक प्रकार के बाइनरी ट्री की निम्नलिखित घोषणा बताती है कि यह कक्षाओं का एक उदाहरण है Eq और Show:

<वाक्यविन्यास लैंग = हास्केल> डेटा बिनट्री ए = लीफ ए | नोड (बिनट्री ए) ए (बिनट्री ए)

     व्युत्पन्न (Eq, दिखाएँ)

</वाक्यविन्यास हाइलाइट>

इसका परिणाम एक समानता समारोह में होता है (==) और एक स्ट्रिंग प्रतिनिधित्व समारोह (show) किसी भी प्रकार के फॉर्म के लिए स्वचालित रूप से परिभाषित किया जा रहा है BinTree T उसे उपलब्ध कराया T स्वयं उन कार्यों का समर्थन करता है।

के व्युत्पन्न उदाहरणों के लिए समर्थन Eq और Show उनके तरीके बनाता है == और show पैरामीट्रिक रूप से बहुरूपी कार्यों से गुणात्मक रूप से भिन्न तरीके से सामान्य: इन कार्यों (अधिक सटीक, कार्यों के प्रकार-अनुक्रमित परिवार) को विभिन्न प्रकार के मूल्यों पर लागू किया जा सकता है, और हालांकि वे प्रत्येक तर्क प्रकार के लिए अलग-अलग व्यवहार करते हैं, समर्थन जोड़ने के लिए थोड़ा काम आवश्यक है एक नए प्रकार के लिए। राल्फ हिंज (2004) ने दिखाया है कि कुछ प्रोग्रामिंग तकनीकों द्वारा उपयोगकर्ता-परिभाषित प्रकार की कक्षाओं के लिए एक समान प्रभाव प्राप्त किया जा सकता है। अन्य शोधकर्ताओं ने हास्केल और हास्केल के विस्तार (नीचे चर्चा की गई) के संदर्भ में इस और अन्य प्रकार की उदारता के लिए दृष्टिकोण प्रस्तावित किया है।

पॉलीपी

PolyP हास्केल (प्रोग्रामिंग भाषा) के लिए पहला सामान्य प्रोग्रामिंग भाषा विस्तार था। पॉलीपी में, सामान्य कार्यों को पॉलीटिपिक कहा जाता है। भाषा एक विशेष निर्माण का परिचय देती है जिसमें इस तरह के बहुरूपी कार्यों को एक नियमित डेटाटाइप के पैटर्न फ़ैक्टर की संरचना पर संरचनात्मक प्रेरण के माध्यम से परिभाषित किया जा सकता है। पॉलीपी में नियमित डेटाटाइप्स हास्केल डेटाटाइप्स का एक सबसेट हैं। एक नियमित डेटाटाइप टी प्रकार का होना चाहिए (प्रकार सिद्धांत) * → *, और यदि परिभाषा में औपचारिक प्रकार का तर्क है, तो सभी पुनरावर्ती कॉलों में फॉर्म टी होना चाहिए। ये प्रतिबंध उच्च-प्रकार के डेटाटाइप्स के साथ-साथ नेस्टेड डेटाटाइप्स को नियंत्रित करते हैं, जहां पुनरावर्ती कॉल एक अलग रूप के होते हैं। PolyP में चपटा कार्य यहाँ एक उदाहरण के रूप में प्रदान किया गया है:

<वाक्यविन्यास लैंग = हास्केल>

  चपटा :: नियमित d => d a -> [a]
  चपटा = काटा fl

  बहुप्ररूपी fl :: f a [a] -> [a]
    का मामला एफ
      g+h -> या तो fl fl
      g*h -> \(x,y) -> fl x ++ fl y
      () -> \x -> []
      पार -> \x -> [x]
      आरईसी -> \x -> एक्स
      डी @ जी -> कॉन्सट। चपटा। पीएमएपी फ़्ल
      कोन टी -> \x -> []

  काटा :: नियमित डी => (FunctorOf d a b -> b) -> d a -> b

</वाक्यविन्यास हाइलाइट>

जेनेरिक हास्केल

जेनेरिक हास्केल हास्केल (प्रोग्रामिंग लैंग्वेज) का एक और विस्तार है, जिसे नीदरलैंड के यूट्रेक्ट विश्वविद्यालय में विकसित किया गया है। इसके द्वारा प्रदान किए जाने वाले एक्सटेंशन हैं:

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

परिणामी प्रकार-अनुक्रमित मान किसी भी प्रकार के लिए विशिष्ट हो सकता है।

• तरह-अनुक्रमित प्रकार प्रकारों पर अनुक्रमित प्रकार होते हैं, जिन्हें * और k → k' दोनों के लिए एक मामला देकर परिभाषित किया जाता है। प्रकार-अनुक्रमित प्रकार को एक प्रकार पर लागू करके उदाहरण प्राप्त किए जाते हैं।
• सामान्य परिभाषाओं का उपयोग उन्हें किसी प्रकार या प्रकार पर लागू करके किया जा सकता है। इसे सामान्य अनुप्रयोग कहा जाता है। परिणाम एक प्रकार या मान है, जो इस बात पर निर्भर करता है कि किस प्रकार की सामान्य परिभाषा लागू की गई है।
• जेनेरिक एब्स्ट्रैक्शन, एक प्रकार के पैरामीटर (किसी दिए गए प्रकार का) को एब्स्ट्रैक्ट करके सामान्य परिभाषाओं को परिभाषित करने में सक्षम बनाता है।
• टाइप-इंडेक्स्ड प्रकार वे प्रकार होते हैं जो टाइप कंस्ट्रक्टर्स पर अनुक्रमित होते हैं। इनका उपयोग अधिक सम्मिलित सामान्य मूल्यों को प्रकार देने के लिए किया जा सकता है। परिणामी प्रकार-अनुक्रमित प्रकार किसी भी प्रकार के लिए विशिष्ट हो सकते हैं।

उदाहरण के तौर पर, जेनेरिक हास्केल में समानता कार्य: <वाक्यविन्यास लैंग = हास्केल>

  Eq टाइप करें {[*]} t1 t2 = t1 -> t2 -> बूल
  Eq टाइप करें {[k -> l]} t1 t2 = forall u1 u2. Eq {[ k ]} u1 u2 -> Eq {[ l ]} (t1 u1) (t2 u2)

  eq के {| t :: k |} :: ईक {[के]} टी टी
  eq के {| Unit |} _ _ = सत्य
  eq के {| :+: |} eqA eqB (Inl a1) (Inl a2) = eqA a1 a2
  eq के {| :+: |} eqA eqB (inr b1) (inr b2) = eqB b1 b2
  eq के {| :+: |} eqA eqB _ _ = झूठा
  eq के {| :*: |} Eq के बाद (a1:*:b1) (a:*:ba) = eqA a1 a2 && eqB b1 b2
  eq के {| Int |} = (==)
  eq के {| Char |} = (==)
  eq के {| Bool |} = (==)

</वाक्यविन्यास हाइलाइट>

साफ

स्वच्छ (प्रोग्रामिंग भाषा) सामान्य प्रोग्रामिंग आधारित प्रदान करता है § PolyP और यह § Generic Haskell जैसा कि GHC ≥ 6.0 द्वारा समर्थित है। यह प्रकार के अनुसार पैरामीट्रिज करता है लेकिन ओवरलोडिंग प्रदान करता है।

अन्य भाषाएँ

एमएल (प्रोग्रामिंग लैंग्वेज) परिवार में भाषाएं पैरामीट्रिक बहुरूपता और जेनेरिक मॉड्यूलर प्रोग्रामिंग के माध्यम से योजना (प्रोग्रामिंग भाषा) समर्थन करती हैं जिन्हें फंक्शनलर्स कहा जाता है। Standard ML और OCaml दोनों functors प्रदान करते हैं, जो क्लास टेम्प्लेट और Ada के जेनेरिक पैकेज के समान हैं। स्कीम (प्रोग्रामिंग लैंग्वेज) सिंटैक्टिक एब्स्ट्रक्शन का भी उदारता से संबंध है - ये वास्तव में C ++ टेम्प्लेट का सुपरसेट हैं।

एक Verilog मॉड्यूल एक या अधिक पैरामीटर ले सकता है, जिसके लिए उनके वास्तविक मान मॉड्यूल के इन्स्टेन्शियशन पर असाइन किए जाते हैं। एक उदाहरण एक सामान्य हार्डवेयर रजिस्टर सरणी है जहां पैरामीटर के माध्यम से सरणी चौड़ाई दी जाती है। इस तरह की एक सरणी, एक सामान्य वायर वेक्टर के साथ संयुक्त, एक सामान्य बफर या मेमोरी मॉड्यूल को एकल मॉड्यूल कार्यान्वयन से मनमाने ढंग से बिट चौड़ाई के साथ बना सकती है। VHDL, Ada से प्राप्त किया जा रहा है, इसमें सामान्य क्षमताएं भी हैं। C (प्रोग्रामिंग लैंग्वेज) टाइप-जेनेरिक एक्सप्रेशन का उपयोग करके समर्थन करता है _Generic कीवर्ड: <वाक्यविन्यास प्रकाश लैंग = सी>

1. define cbrt(x) _Generic((x), long double: cbrtl, \

                             डिफ़ॉल्ट: सीबीआरटी, \
                             फ्लोट: cbrtf)(x)</syntaxhighlight>

यह भी देखें

• संकल्पना (जेनेरिक प्रोग्रामिंग)
• आंशिक मूल्यांकन
• टेम्पलेट मेटाप्रोग्रामिंग
• बहुरूपता टाइप करें

स्रोत

• Musser, D. R.; Stepanov, A. A. (1989). "Generic programming". In P. Gianni (ed.). प्रतीकात्मक और बीजगणितीय संगणना: अंतर्राष्ट्रीय संगोष्ठी ISSAC 1988. Lecture Notes in Computer Science. Vol. 358. pp. 13–25. doi:10.1007/3-540-51084-2_2. ISBN 978-3-540-51084-0.
• Stroustrup, Bjarne (2007). वास्तविक दुनिया में और उसके लिए एक भाषा का विकास: C++ 1991-2006 (PDF). ACM HOPL 2007.
• Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994). डिज़ाइन पैटर्न: पुन: प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर के तत्व. Addison-Wesley. Bibcode:1995dper.book.....G. ISBN 0-201-63361-2.

आगे की पढाई

• Gabriel Dos Reis and Jaakko Järvi, What is Generic Programming?, LCSD 2005 Archived 28 August 2019 at the Wayback Machine.
• Gibbons, Jeremy (2007). Backhouse, R.; Gibbons, J.; Hinze, R.; Jeuring, J. (eds.). Datatype-generic programming. Spring School on Datatype-Generic Programming 2006. Lecture Notes in Computer Science. Vol. 4719. Heidelberg: Springer. pp. 1–71. CiteSeerX 10.1.1.159.1228.
• Meyer, Bertrand (1986). "Genericity versus inheritance". Conference proceedings on Object-oriented programming systems, languages and applications - OOPSLA '86. pp. 391–405. doi:10.1145/28697.28738. ISBN 0897912047. S2CID 285030.

इस पेज में लापता आंतरिक लिंक की सूची

• एमएल (प्रोग्रामिंग भाषा)
• डाटा प्रकार
• समारोह (कंप्यूटर विज्ञान)
• एफिल (प्रोग्रामिंग भाषा)
• पायथन (प्रोग्रामिंग भाषा)
• सामान्य समारोह
• इटरेटर
• एल्गोरिदम का विश्लेषण
• संकलन समय
• वस्तु उन्मुख कार्यकर्म
• सरणी डेटा प्रकार
• संरचनात्मक प्रकार प्रणाली
• टेम्पलेट (प्रोग्रामिंग)
• रन टाइम (कार्यक्रम जीवनचक्र चरण)
• प्रकार की सुरक्षा
• साहचर्य सरणी
• जटिल संख्या
• आंशिक टेम्पलेट विशेषज्ञता
• अवधारणाएं (सी ++)
• अनुमान टाइप करें
• रूपांतरण टाइप करें
• संशोधन (कंप्यूटर विज्ञान)
• मुक्केबाजी (कंप्यूटर विज्ञान)
• सुरक्षित टाइप करें
• प्रकार (प्रकार सिद्धांत)
• उट्रेच विश्वविद्यालय

बाहरी कड़ियाँ

• generic-programming.org
• Alexander A. Stepanov, Collected Papers of Alexander A. Stepanov (creator of the STL)

C++/D

• Walter Bright, Templates Revisited.
• David Vandevoorde, Nicolai M Josuttis, C++ Templates: The Complete Guide, 2003 Addison-Wesley. ISBN 0-201-73484-2

C#/.NET

• Jason Clark, "Introducing Generics in the Microsoft CLR," September 2003, MSDN Magazine, Microsoft.
• Jason Clark, "More on Generics in the Microsoft CLR," October 2003, MSDN Magazine, Microsoft.
• M. Aamir Maniar, Generics.Net. An open source generics library for C#.

Delphi/Object Pascal

• Nick Hodges, "Delphi 2009 Reviewers Guide," October 2008, Embarcadero Developer Network, Embarcadero.
• Craig Stuntz, "Delphi 2009 Generics and Type Constraints," October 2008
• Dr. Bob, "Delphi 2009 Generics"
• Free Pascal: Free Pascal Reference guide Chapter 8: Generics, Michaël Van Canneyt, 2007
• Delphi for Win32: Generics with Delphi 2009 Win32, Sébastien DOERAENE, 2008
• Delphi for .NET: Delphi Generics, Felix COLIBRI, 2008

Eiffel

• Eiffel ISO/ECMA specification document

Haskell

• Johan Jeuring, Sean Leather, José Pedro Magalhães, and Alexey Rodriguez Yakushev. Libraries for Generic Programming in Haskell. Utrecht University.
• Dæv Clarke, Johan Jeuring and Andres Löh, The Generic Haskell user's guide
• Ralf Hinze, "Generics for the Masses," In Proceedings of the ACM SIGPLAN International Conference on Functional Programming (ICFP), 2004.
• Simon Peyton Jones, editor, The Haskell 98 Language Report, Revised 2002.
• Ralf Lämmel and Simon Peyton Jones, "Scrap Your Boilerplate: A Practical Design Pattern for Generic Programming," In Proceedings of the ACM SIGPLAN International Workshop on Types in Language Design and Implementation (TLDI'03), 2003. (Also see the website devoted to this research)
• Andres Löh, Exploring Generic Haskell, PhD thesis, 2004 Utrecht University. ISBN 90-393-3765-9
• Generic Haskell: a language for generic programming

Java

• Gilad Bracha, Generics in the Java Programming Language, 2004.
• Maurice Naftalin and Philip Wadler, Java Generics and Collections, 2006, O'Reilly Media, Inc. ISBN 0-596-52775-6
• Peter Sestoft, Java Precisely, Second Edition, 2005 MIT Press. ISBN 0-262-69325-9
• Generic Programming in Java, 2004 Sun Microsystems, Inc.
• Angelika Langer, Java Generics FAQs

श्रेणी: उदाहरण सी शार्प कोड वाले लेख