एकाधिक प्रेषण

From Vigyanwiki
Polymorphism
Ad hoc polymorphism
Parametric polymorphism
Subtyping

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

प्रेषण को समझना

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

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

अधिक पारंपरिक में, अर्थात् गतिशील प्रेषण सिंगल और एकाधिक प्रेषण ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज में जब एक विधि की मांग की जाती है और इस प्रकार स्मॉलटाक में एक संदेश भेजना और सी ++ में एक सदस्य प्रकार्य को कॉल करते हैं इसके एक तर्क को विशेष रूप से माना जाता है और यह निर्धारित करने के लिए प्रयोग किया जाता है कि उस नाम की विधि संभावित रूप से कई वर्गों को प्रयुक्त किया जाता है। कई लैंग्वेज में, विशेष तर्क को वाक्यगत रूप से संकेत द्वारा इंगित किया जाता है; उदाहरण के लिए, कई प्रोग्रामिंग लैंग्वेज मे एक विधि कॉल करने में बिंदु से पहले विशेष तर्क देते हैं: special.method(other, arguments, here), जिससे कि lion.sound() एक दहाड़ उत्पन्न करता है, जबकि sparrow.sound() एक चीप उत्पन्न करता है।

इसके विपरीत, एकाधिक प्रेषण वाली लैंग्वेज में, चयनित विधि केवल वह है जिसके तर्क प्रकार्य कॉल की संख्या और प्रकार से मेल खाते हैं। किसी विशेष कॉल में किए गए फंक्शन/विधि के स्वामित्व वाले कोई विशेष तर्क नहीं है.।

सामान्य लिस्प ऑब्जेक्ट प्रणाली (सीएलओएस) एकाधिक प्रेषण का एक प्रारंभिक और प्रसिद्ध उदाहरण है। एकाधिक प्रेषण के उपयोग का एक और उल्लेखनीय उदाहरण जूलिया प्रोग्रामिंग लैंग्वेज के रूप में है।

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

डेटा प्रकार

उन लैंग्वेज के साथ काम करते समय जो कंपाइलिंग समय पर डेटा प्रकारों में डिस्क्रिमिनेशन कर सकती हैं, तब विकल्पों में से चयन हो सकता है। जिससे कि कंपाइलिंग समय चयन के लिए ऐसे वैकल्पिक कार्यों को बनाने का कार्य सामान्यतः फंक्शन ओवरलोडिंग के रूप में जाना जाता है।

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

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

विषय

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

अभिव्यक्ति और प्रतिरूपकता

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

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

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

एम्बिगुइटी

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

संभावित रेसोलुशन के रूप में सम्मलित हैं,

  • किसी भी अस्पष्ट कॉल को त्रुटि के रूप में माना जा सकता है। इसे संकलन समय पर या अन्यथा परिनियोजन से पहले कैप्चर किया जाता है, लेकिन रनटाइम तक पता नहीं लगाया जा सकता है और रनटाइम त्रुटि उत्पन्न हो सकती है।।
  • तर्कों को क्रमबद्ध करना उदाहरण के रूप में सबसे विशिष्ट तर्क की स्थिति का चयन किया जाता है और बाद के तर्कों को एम्बिगुइटी समाधान के लिए नहीं माना जाता है जब तक कि पहला तर्क समस्या को हल करने के लिए अपर्याप्त नहीं होता है।
  • एक दिशा या किसी अन्य में एम्बिगुइटी को हल करने के लिए अन्य नियमों का निर्माण किया जाता है और इस प्रकार कभी-कभी ऐसे नियम अनैतिक और आश्चर्यजनक रूप में हो सकते हैं। उदाहरण के लिए, सी ++ में स्थिर अधिभार संकल्प के नियमों के रूप में होता है, जो वास्तव में मेल खाता है, जिससे कि एक प्रकार से बेहतर मिलान माना जाता है जो आधार प्रकार संदर्भ या सामान्य टेम्पलेट पैरामीटर से मेल खाता है। चूंकि, यदि एकमात्र संभावित मिलान या तो आधार प्रकार या सामान्य पैरामीटर के माध्यम से होता है, तो सामान्य पैरामीटर को आधार प्रकार से अधिक पसंद किया जाता है, एक नियम जो कभी-कभी आश्चर्यजनक व्यवहार उत्पन्न करता है।

एफिशिएंसी

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

बहु-प्रेषण का कुशल कार्यान्वयन एक सतत शोध समस्या के रूप में बनी हुई है।

अभ्यास में प्रयोग करें

यह अनुमान लगाने के लिए कि प्रैक्टिस में कितनी बार एकाधिक प्रेषण का उपयोग किया जाता है। मुस्चेविसी एट अल,[2] गतिशील प्रेषण का उपयोग करने वाले प्रोग्राम का अध्ययन किया जाता है। उन्होंने छह भिन्न -भिन्न लैंग्वेज में लिखे गए नौ अनुप्रयोगों का विश्लेषण किया है, जिनमें ज्यादातर कंपाइलर थे कॉमन लिस्प ऑब्जेक्ट प्रणाली डायलन (प्रोग्रामिंग लैंग्वेज) , सेसिल (प्रोग्रामिंग लैंग्वेज) , मल्टीजावा, डीजल और नाइस का विश्लेषण किया है। उनके परिणाम बताते हैं कि जेनेरिक फंक्शंस का 13–32% एक तर्क के गतिशील प्रकार का उपयोग करते हैं, जबकि उनमें से 2.7–6.5% गतिशील प्रकार के कई तर्कों का उपयोग करते हैं। शेष 65-93% सामान्य कार्यों में एक ठोस विधि ओवरराइडर के रूप में है और इसलिए उनके तर्कों के सक्रिय प्रकारों का उपयोग करने के लिए विचार नहीं किया जाता है। इसके अतिरिक्त, अध्ययन की रिपोर्ट है कि 2-20% सामान्य कार्यों में दो और 3-6% में तीन ठोस कार्य कार्यान्वयन के रूप में है और इस प्रकार अधिक ठोस ओवरराइडर्स वाले कार्यों के लिए संख्या तेजी से कमी आती है।

जूलिया प्रोग्रामिंग लैंग्वेज में एकाधिक प्रेषण का बहुत अधिक उपयोग किया जाता है, जहां एकाधिक प्रेषण लैंग्वेज की उत्पत्ति से एक केंद्रीय डिजाइन अवधारणा के रूप में थी जिससे की प्रति जेनेरिक प्रकार्य की विधि के औसत संख्या पर मुस्चेविसी के समान आंकड़े एकत्र करता है और इस प्रकार यह पाया गया कि जूलिया मानक लाइब्रेरी मुस्चेविसी द्वारा विश्लेषण की गई अन्य लैंग्वेज की तुलना में दोगुने से अधिक और ऑपरेटर (कंप्यूटर प्रोग्रामिंग) की स्थिति में 10 गुना से अधिक का उपयोग करता है।[3]

इन पत्रों के डेटा को निम्नलिखित तालिका में संक्षेपित किया गया है, जहाँ प्रेषण अनुपात DR सामान्य कार्य प्रति विधियों की औसत संख्या के रूप में होता है; पसंद अनुपात CR विधियों की संख्या के वर्ग का माध्य होता है और इस प्रकार बड़ी संख्या में विधियों के साथ कार्यों की आवृत्ति को अच्छे ढंग से मापने के लिए किया जाता है;[2][3]और विशेषज्ञता की डिग्री DoS प्रति विधि प्रकार-विशिष्ट तर्कों की औसत संख्या के रूप में होती है, अर्थात उन तर्कों की संख्या जिन्हें प्रेषित किया जाता है।

लैंग्वेज औसत # तरीके (डीआर) विकल्प अनुपात (सीआर) विशेषज्ञता की डिग्री (DoS)
सेसिल[2] 2.33 63.30 1.06
कॉमन लिस्प (सीएमयू)[2] 2.03 6.34 1.17
कॉमन लिस्प (मैकसीएलआईएम)[2] 2.32 15.43 1.17
कॉमन लिस्प (स्टील बैंक)[2] 2.37 26.57 1.11
डीज़ल[2] 2.07 31.65 0.71
डायलन (ग्वाइडियन))[2] 1.74 18.27 2.14
डायलन (ओपनडायलन )[2] 2.51 43.84 1.23
जूलिया[3] 5.86 51.44 1.54
जूलिया (केवल ऑपरेटर)[3] 28.13 78.06 2.01
मल्टीजावा[2] 1.50 8.92 1.02
नाइस[2] 1.36 3.46 0.33


सिद्धांत

एकाधिक प्रेषण लैंग्वेज के सिद्धांत को सबसे पहले कास्टाग्ना एट अल.द्वारा विकसित किया गया था, जो लेट बाइनडींग के साथ अतिभारित कार्यों के लिए एक मॉडल को परिभाषित करता है।[4][5] इसने ऑब्जेक्ट ओरिएंटेड लैंग्वेज के कोवेरीअन्स और कॉनटरावेरीअन्स (कंप्यूटर विज्ञान) की पहली औपचारिकता को जन्म दिया था,[6] और बाइनरी विधियों की समस्या का समाधान किया जाता है।[7]

उदाहरण

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

अंतर्निहित एकाधिक प्रेषण वाली लैंग्वेज

C#

C शार्प प्रोग्रामिंग लैंग्वेज ने संस्करण 4 में गतिशील मल्टीमेथड्स के लिए समर्थन प्रस्तुत किया है।[8] अप्रैल 2010 में 'डायनामिक' कीवर्ड का उपयोग करते हुए। निम्न उदाहरण मल्टीमेथ्स को प्रदर्शित करता है। कई अन्य वैधानिक रूप से टाइप की गई लैंग्वेज की तरह C# भी स्टैटिक मेथड ओवरलोडिंग का समर्थन करता है।[9] माइक्रोसॉफ्ट आशा करता है कि अधिकांश परिदृश्यों में डेवलपर्स गतिशील टाइपिंग पर स्थिर टाइपिंग का चयन करते है।[10] 'डायनामिक' कीवर्ड कॉम ऑब्जेक्ट्स और डायनामिक रूप से टाइप की गई डॉट नेट लैंग्वेज के साथ इंटरऑपरेबिलिटी का समर्थन करता है।

Csharp ColliderLibrary.svg

नीचे दिया गया उदाहरण C# 9 और C# 10 में शुरू की गई फीचर का उपयोग करता है। 

 using static ColliderLibrary;

Console.WriteLine(Collide(new Asteroid(101), new Spaceship(300)));
Console.WriteLine(Collide(new Asteroid(10), new Spaceship(10)));
Console.WriteLine(Collide(new Spaceship(101), new Spaceship(10)));

string Collide(SpaceObject x, SpaceObject y) =>
 x.Size > 100 && y.Size > 100
  ? "Big boom!"
  : CollideWith(x as dynamic, y as dynamic); // Dynamic dispatch to CollideWith method

class ColliderLibrary
{
 public static string CollideWith(Asteroid x, Asteroid y) => "a/a";
 public static string CollideWith(Asteroid x, Spaceship y) => "a/s";
 public static string CollideWith(Spaceship x, Asteroid y) => "s/a";
 public static string CollideWith(Spaceship x, Spaceship y) => "s/s";
}

abstract record SpaceObject(int Size);
record Asteroid(int Size)A: SpaceObject(Size);
record Spaceship(int Size)S: SpaceObject(Size);

Output: 

 Big boom!

a/s
s/s

ग्रूवी

अपाचे ग्रूवी एक सामान्य प्रयोजन वाली जावा (प्रोग्रामिंग लैंग्वेज) कम्पेटिबल/इंटरयूजेबल जावा वर्चुअल मशीन लैंग्वेज के रूप में है, जो जावा के विपरीत, लेट बाइंडिंग/एकाधिक प्रेषण का उपयोग करती है।[11] 

/*
    Groovy implementation of C# example above
    Late binding works the same when using non-static methods or compiling class/methods statically
    (@CompileStatic annotation)
*/
class Program {
    static void main(String[] args) {
        println Collider.collide(new Asteroid(101), new Spaceship(300))
        println Collider.collide(new Asteroid(10), new Spaceship(10))
        println Collider.collide(new Spaceship(101), new Spaceship(10))
    }
}

class Collider {
    static String collide(SpaceObject x, SpaceObject y) {
        (x.size > 100 && y.size > 100) ? "big-boom" : collideWith(x, y)  // Dynamic dispatch to collideWith method
    }

    private static String collideWith(Asteroid x, Asteroid y) { "a/a" }
    private static String collideWith(Asteroid x, Spaceship y) { "a/s" }
    private static String collideWith(Spaceship x, Asteroid y) { "s/a" }
    private static String collideWith(Spaceship x, Spaceship y) { "s/s"}
}

class SpaceObject {
    int size
    SpaceObject(int size) { this.size = size }
}

@InheritConstructors class Asteroid extends SpaceObject {}
@InheritConstructors class Spaceship extends SpaceObject {}


सामान्य लिस्प

कॉमन लिस्प जैसी कई प्रेषण वाली लैंग्वेज में, यह इस तरह दिख सकती है और इस प्रकार कॉमन लिस्प का उदाहरण दिखाया गया है 

(defmethod collide-with ((x asteroid) (y asteroid))
  ;; deal with asteroid hitting asteroid
  )
(defmethod collide-with ((x asteroid) (y spaceship))
  ;; deal with asteroid hitting spaceship
  )
(defmethod collide-with ((x spaceship) (y asteroid))
  ;; deal with spaceship hitting asteroid
  )
(defmethod collide-with ((x spaceship) (y spaceship))
  ;; deal with spaceship hitting spaceship
  )

और इसी तरह अन्य विधि के लिए स्पष्ट परीक्षण और गतिशील कास्टिंग का उपयोग किया जाता है।

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

जूलिया

जूलिया प्रोग्रामिंग लैंग्वेज में बिल्ट-इन एकाधिक प्रेषण के रूप में होता है और यह लैंग्वेज डिजाइन के लिए केंद्रीय है।[3] उपरोक्त उदाहरण का जूलिया संस्करण में ऐसा दिखाई देता है। 

abstract type SpaceObject end

struct Asteroid <: SpaceObject
    size::Int    
end
struct Spaceship <: SpaceObject
    size::Int                  
end              

collide_with(::Asteroid, ::Spaceship) = "a/s"
collide_with(::Spaceship, ::Asteroid) = "s/a"
collide_with(::Spaceship, ::Spaceship) = "s/s"
collide_with(::Asteroid, ::Asteroid) = "a/a"

collide(x::SpaceObject, y::SpaceObject) = (x.size > 100 && y.size > 100) ? "Big boom!" : collide_with(x, y)

आउटपुट: 

julia> collide(Asteroid(101), Spaceship(300))
"Big boom!"

julia> collide(Asteroid(10), Spaceship(10))
"a/s"

julia> collide(Spaceship(101), Spaceship(10))
"s/s"

राकु

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

इसमें मल्टीमेथ्स और मल्टीसब दोनों होते है। चूँकि, अधिकांश ऑपरेटर सबरूटीन्स के रूप में होते हैं, इसमें कई प्रेषण ऑपरेटर्स भी होते हैं।

सामान्य प्रकार की बाधाओं के साथ-साथ, इसमें बाधाएँ भी होती हैं जो बहुत विशिष्ट सबरूटीन्स बनाने की अनुमति देती हैं। 

subset Mass of Real where 0 ^..^ Inf; 
role Stellar-Object {
    has Mass $.mass is required;
    method name () returns Str {...};
}
class Asteroid does Stellar-Object {
    method name () { 'an asteroid' }
}
class Spaceship does Stellar-Object {
    has Str $.name = 'some unnamed spaceship';
}
my Str @destroyed = < obliterated destroyed mangled >;
my Str @damaged = « damaged 'collided with' 'was damaged by' »;

# We add multi candidates to the numeric comparison operators because we are comparing them numerically,
# but makes no sense to have the objects coerce to a Numeric type.
# ( If they did coerce we wouldn't necessarily need to add these operators. )
# We could have also defined entirely new operators this same way.
multi sub infix:« <=> » ( Stellar-Object:D $a, Stellar-Object:D $b ) { $a.mass <=> $b.mass }
multi sub infix:« < » ( Stellar-Object:D $a, Stellar-Object:D $b ) { $a.mass < $b.mass }
multi sub infix:« > » ( Stellar-Object:D $a, Stellar-Object:D $b ) { $a.mass > $b.mass }
multi sub infix:« == » ( Stellar-Object:D $a, Stellar-Object:D $b ) { $a.mass == $b.mass }

# Define a new multi dispatcher, and add some type constraints to the parameters.
# If we didn't define it we would have gotten a generic one that didn't have constraints.
proto sub collide ( Stellar-Object:D $, Stellar-Object:D $ ) {*}

# No need to repeat the types here since they are the same as the prototype.
# The 'where' constraint technically only applies to $b not the whole signature.
# Note that the 'where' constraint uses the `<` operator candidate we added earlier.
multi sub collide ( $a, $b where $a < $b ) {
    say "$a.name() was @destroyed.pick() by $b.name()";
}
multi sub collide ( $a, $b where $a > $b ) {
    # redispatch to the previous candidate with the arguments swapped
    samewith $b, $a;
}

# This has to be after the first two because the other ones
# have 'where' constraints, which get checked in the
# order the subs were written. ( This one would always match. )
multi sub collide ( $a, $b ) {
    # randomize the order
    my ($n1, $n2) = ( $a.name, $b.name ).pick(*);
    say "$n1 @damaged.pick() $n2";
}

# The following two candidates can be anywhere after the proto,
# because they have more specialized types than the preceding three.

# If the ships have unequal mass one of the first two candidates gets called instead.
multi sub collide ( Spaceship $a, Spaceship $b where $a == $b ){
    my ($n1, $n2) = ( $a.name, $b.name ).pick(*);
    say "$n1 collided with $n2, and both ships were ",
    ( @destroyed.pick, 'left damaged' ).pick;
}

# You can unpack the attributes into variables within the signature.
# You could even have a constraint on them `(:mass($a) where 10)`.
multi sub collide ( Asteroid $ (:mass($a)), Asteroid $ (:mass($b)) ){
    say "two asteroids collided and combined into one larger asteroid of mass { $a + $b }";
}

my Spaceship $Enterprise .= new(:mass(1),:name('The Enterprise'));
collide Asteroid.new(:mass(.1)), $Enterprise;
collide $Enterprise, Spaceship.new(:mass(.1));
collide $Enterprise, Asteroid.new(:mass(1));
collide $Enterprise, Spaceship.new(:mass(1));
collide Asteroid.new(:mass(10)), Asteroid.new(:mass(5));


बहु-प्रेषण पुस्तकालयों के साथ लैंग्वेज का विस्तार

जावास्क्रिप्ट

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

जावास्क्रिप्ट में गतिशील रूप से टाइप किया गया संस्करण होता है। 

import { multi, method } from '@arrows/multimethod'

class Asteroid {}
class Spaceship {}

const collideWith = multi(
  method([Asteroid, Asteroid], (x, y) => {
    // deal with asteroid hitting asteroid
  }),
  method([Asteroid, Spaceship], (x, y) => {
    // deal with asteroid hitting spaceship
  }),
  method([Spaceship, Asteroid], (x, y) => {
    // deal with spaceship hitting asteroid
  }),
  method([Spaceship, Spaceship], (x, y) => {
    // deal with spaceship hitting spaceship
  }),
)

टाइपस्क्रिप्ट में स्टेटिकली टाइप किया गया संस्करण होता है, 

import { multi, method, Multi } from '@arrows/multimethod'

class Asteroid {}
class Spaceship {}

type CollideWith = Multi & {
  (x: Asteroid, y: Asteroid): void
  (x: Asteroid, y: Spaceship): void
  (x: Spaceship, y: Asteroid): void
  (x: Spaceship, y: Spaceship): void
}

const collideWith: CollideWith = multi(
  method([Asteroid, Asteroid], (x, y) => {
    // deal with asteroid hitting asteroid
  }),
  method([Asteroid, Spaceship], (x, y) => {
    // deal with asteroid hitting spaceship
  }),
  method([Spaceship, Asteroid], (x, y) => {
    // deal with spaceship hitting asteroid
  }),
  method([Spaceship, Spaceship], (x, y) => {
    // deal with spaceship hitting spaceship
  }),
)

पायथन

लाइब्रेरी (कंप्यूटिंग) एक्सटेंशन का उपयोग करके पायथन (प्रोग्रामिंग लैंग्वेज ) में एकाधिक प्रेषण को जोड़ा जा सकता है। उदाहरण के लिए, मॉड्यूल मल्टीमेथोड.पायथन का उपयोग करता है[13] और मॉड्यूल पायथन के लिए अंतर्निहित सिंटैक्स या कीवर्ड को बदलने के बिना सीएलओएस स्टाइल बहुविधि प्रदान करता है।Cite error: Closing </ref> missing for <ref> tag 

from multimethods import Dispatch
from game_objects import Asteroid, Spaceship
from game_behaviors import as_func, ss_func, sa_func

collide = Dispatch()
collide.add_rule((Asteroid, Spaceship), as_func)
collide.add_rule((Spaceship, Spaceship), ss_func)
collide.add_rule((Spaceship, Asteroid), sa_func)


def aa_func(a, b):
    """Behavior when asteroid hits asteroid."""
    # ...define new behavior...


collide.add_rule((Asteroid, Asteroid), aa_func)
# ...later...
collide(thing1, thing2)

कार्यात्मक रूप से, यह उदाहरण सीएलओएस करने के लिए बहुत ही समान है, लेकिन सिंटैक्स पारंपरिक पायथन के रूप में है।

पायथन 2.4 डेकोरेटर्स का उपयोग करते हुए, गुइडो वैन रोसुम ने एक सरल सिंटैक्स के साथ मल्टीमेथड्स का एक नमूना कार्यान्वयन किया है।

@multimethod(Asteroid, Asteroid)
def collide(a, b):
    """Behavior when asteroid hits a asteroid."""
    # ...define new behavior...
@multimethod(Asteroid, Spaceship)
def collide(a, b):
    """Behavior when asteroid hits a spaceship."""
    # ...define new behavior...
# ... define other multimethod rules ...


और फिर यह मल्टीमेथड डेकोरेटर को परिभाषित करता है।

पीक-नियम पैकेज उपरोक्त उदाहरण के समान सिंटैक्स के साथ कई प्रेषण प्रदान करता है।[14] इसे बाद में पायथन प्रोटोकॉल द्वारा बदल दिया जाता है।[15]

रेग लाइब्रेरी भी एकाधिक और विधेय प्रेषण का समर्थन करता है।[16]

पायथन सिंटैक्स और शब्दार्थ प्रकार्य एनोटेशन की शुरुआत के साथ सरल सिंटैक्स के साथ कई प्रेषण संभव होते हैं। उदाहरण के लिए, प्लम-प्रेषण का उपयोग किया जाता है। 

from plum import dispatch


@dispatch
def collide(a: Asteroid, b: Asteroid):
    """Behavior when asteroid hits a asteroid."""
    # ...define new behavior...
    
@dispatch
def collide(a: Asteroid, b: Spaceship):
    """Behavior when asteroid hits a spaceship."""
    # ...define new behavior...
    
# ...define further rules...


एकाधिक प्रेषण का अनुकरण

C

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

typedef void (*CollisionCase)(void);

void collision_AA(void) { /* handle Asteroid-Asteroid collision  */ };
void collision_AS(void) { /* handle Asteroid-Spaceship collision */ };
void collision_SA(void) { /* handle Spaceship-Asteroid collision */ };
void collision_SS(void) { /* handle Spaceship-Spaceship collision*/ };

typedef enum {
    THING_ASTEROID = 0,
    THING_SPACESHIP,
    THING_COUNT /* not a type of thing itself, instead used to find number of things */
} Thing;

CollisionCase collisionCases[THING_COUNT][THING_COUNT] = {
    {&collision_AA, &collision_AS},
    {&collision_SA, &collision_SS}
};

void collide(Thing a, Thing b) {
    (*collisionCases[a][b])();
}

int main(void) {
    collide(THING_SPACESHIP, THING_ASTEROID);
}

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

#include <stdio.h>
#include <cos/Object.h>
#include <cos/gen/object.h>

// classes

defclass (Asteroid)
// data members
endclass

defclass (Spaceship)
// data members
endclass

// generics

defgeneric (_Bool, collide_with, _1, _2);

// multimethods

defmethod (_Bool, collide_with, Asteroid, Asteroid)
 // deal with asteroid hitting asteroid
endmethod

defmethod (_Bool, collide_with, Asteroid, Spaceship)
 // deal with asteroid hitting spaceship
endmethod

defmethod (_Bool, collide_with, Spaceship, Asteroid)
 // deal with spaceship hitting asteroid
endmethod

defmethod (_Bool, collide_with, Spaceship, Spaceship)
 // deal with spaceship hitting spaceship
endmethod

// example of use

int main(void)
{
  OBJ a = gnew(Asteroid);
  OBJ s = gnew(Spaceship);

  printf("<a,a> = %d\n", collide_with(a, a));
  printf("<a,s> = %d\n", collide_with(a, s));
  printf("<s,a> = %d\n", collide_with(s, a));
  printf("<s,s> = %d\n", collide_with(s, s));

  grelease(a);
  grelease(s);
}


C++

2021 तक, C++ मूल रूप से केवल एक प्रेषण का समर्थन करता है, चूंकि 2007 में बज़्ने स्ट्रॉस्ट्रुप और सहयोगियों द्वारा बहु-विधियों एकाधिक प्रेषण को जोड़ने का प्रस्ताव दिया गया था।[18] इस सीमा के आसपास काम करने के विधि समान हैं, विजिटर पैटर्न, गतिशील कास्ट या लाइब्रेरी का उपयोग करते है 

 // Example using run time type comparison via dynamic_cast

 struct Thing {
     virtual void collideWith(Thing& other) = 0;
 };

 struct Asteroid : Thing {
     void collideWith(Thing& other) {
         // dynamic_cast to a pointer type returns NULL if the cast fails
         // (dynamic_cast to a reference type would throw an exception on failure)
         if (auto asteroid = dynamic_cast<Asteroid*>(&other)) {
             // handle Asteroid-Asteroid collision
         } else if (auto spaceship = dynamic_cast<Spaceship*>(&other)) {
             // handle Asteroid-Spaceship collision
         } else {
             // default collision handling here
         }
     }
 };

 struct Spaceship : Thing {
     void collideWith(Thing& other) {
         if (auto asteroid = dynamic_cast<Asteroid*>(&other)) {
             // handle Spaceship-Asteroid collision
         } else if (auto spaceship = dynamic_cast<Spaceship*>(&other)) {
             // handle Spaceship-Spaceship collision
         } else {
             // default collision handling here
         }
     }
 };

या पॉइंटर-टू-मेथड लुकअप टेबल के रूप में दिखाया गया है, 

#include <cstdint>
#include <typeinfo>
#include <unordered_map>

class Thing {
  protected:
    Thing(std::uint32_t cid) : tid(cid) {}
    const std::uint32_t tid; // type id

    typedef void (Thing::*CollisionHandler)(Thing& other);
    typedef std::unordered_map<std::uint64_t, CollisionHandler> CollisionHandlerMap;

    static void addHandler(std::uint32_t id1, std::uint32_t id2, CollisionHandler handler) {
        collisionCases.insert(CollisionHandlerMap::value_type(key(id1, id2), handler));
    }
    static std::uint64_t key(std::uint32_t id1, std::uint32_t id2) {
        return std::uint64_t(id1) << 32 | id2;
    }

    static CollisionHandlerMap collisionCases;

  public:
    void collideWith(Thing& other) {
        auto handler = collisionCases.find(key(tid, other.tid));
        if (handler != collisionCases.end()) {
            (this->*handler->second)(other); // pointer-to-method call
        } else {
            // default collision handling
        }
    }
};

class Asteroid: public Thing {
    void asteroid_collision(Thing& other)   { /*handle Asteroid-Asteroid collision*/ }
    void spaceship_collision(Thing& other)  { /*handle Asteroid-Spaceship collision*/}

  public:
    Asteroid(): Thing(cid) {}
    static void initCases();
    static const std::uint32_t cid;
};

class Spaceship: public Thing {
    void asteroid_collision(Thing& other)   { /*handle Spaceship-Asteroid collision*/}
    void spaceship_collision(Thing& other)  { /*handle Spaceship-Spaceship collision*/}

  public:
    Spaceship(): Thing(cid) {}
    static void initCases();
    static const std::uint32_t cid; // class id
};

Thing::CollisionHandlerMap Thing::collisionCases;
const std::uint32_t Asteroid::cid = typeid(Asteroid).hash_code();
const std::uint32_t Spaceship::cid = typeid(Spaceship).hash_code();

void Asteroid::initCases() {
    addHandler(cid, cid, CollisionHandler(&Asteroid::asteroid_collision));
    addHandler(cid, Spaceship::cid, CollisionHandler(&Asteroid::spaceship_collision));
}

void Spaceship::initCases() {
    addHandler(cid, Asteroid::cid, CollisionHandler(&Spaceship::asteroid_collision));
    addHandler(cid, cid, CollisionHandler(&Spaceship::spaceship_collision));
}

int main() {
    Asteroid::initCases();
    Spaceship::initCases();

    Asteroid  a1, a2;
    Spaceship s1, s2;

    a1.collideWith(a2);
    a1.collideWith(s1);

    s1.collideWith(s2);
    s1.collideWith(a1);
}

योमम2 लाइब्रेरी[19] ओपन मल्टीमेथड्स का तेज, ऑर्थोगोनल कार्यान्वयन प्रदान करता है।

ओपन पद्धति को घोषित करने के लिए सिंटैक्स सी ++ कार्यान्वयन के प्रस्ताव से प्रेरित है। लाइब्रेरी के लिए आवश्यक है कि उपयोगकर्ता आभासी तर्क और उनके उप-वर्ग के रूप में उपयोग की जाने वाली सभी कक्षाओं को पंजीकृत करता है, लेकिन वर्तमान कोड में किसी भी संशोधन की आवश्यकता नहीं है। विधियों को सामान्य इनलाइन C++ फ़ंक्शंस के रूप में कार्यान्वित किया जाता है और इस प्रकार उन्हें अतिभारित किया जा सकता है और उन्हें सूचक द्वारा पारित किया जा सकता है। आभासी तर्कों की संख्या की कोई सीमा नहीं होती है और उन्हें मनमाने ढंग से गैर-आभासी तर्कों के साथ मिलाया जा सकता है।

स्मृति उपयोग को कम करते हुए, निरंतर समय में विधि कॉल को प्रयुक्त करने के लिए लाइब्रेरी प्रोद्योगिकीय के संयोजन संपीड़ित प्रेषण तालिका, टक्कर मुक्त पूर्णांक हैश तालिका का उपयोग करता है। जब एक आधुनिक ऑप्टिमाइज़िंग कंपाइलर का उपयोग किया जाता है, तो एक साधारण वर्चुअल सदस्य प्रकार्य को कॉल करने की तुलना में एक एकल आभासी तर्क के साथ एक खुली विधि को कॉल भेजने में केवल 15-30% अधिक समय लगता है।

एस्टरोइड को उदाहरण के रूप में निम्नानुसार प्रयुक्त किया जा सकता है। 

#include <yorel/yomm2/keywords.hpp>
#include <memory>

class Thing {
  public:
    virtual ~Thing() {}
};

class Asteroid : public Thing {
};

class Spaceship : public Thing {
};

register_classes(Thing, Spaceship, Asteroid);

declare_method(void, collideWith, (virtual_<Thing&>, virtual_<Thing&>));

define_method(void, collideWith, (Thing& left, Thing& right)) {
    // default collision handling
}

define_method(void, collideWith, (Asteroid& left, Asteroid& right)) {
    // handle Asteroid-Asteroid collision
}

define_method(void, collideWith, (Asteroid& left, Spaceship& right)) {
    // handle Asteroid-Spaceship collision
}

define_method(void, collideWith, (Spaceship& left, Asteroid& right)) {
    // handle Spaceship-Asteroid collision
}

define_method(void, collideWith, (Spaceship& left, Spaceship& right)) {
    // handle Spaceship-Spaceship collision
}

int main() {
    yorel::yomm2::update_methods();

    std::unique_ptr<Thing> a1(std::make_unique<Asteroid>()),
        a2(std::make_unique<Asteroid>());
    std::unique_ptr<Thing> s1(std::make_unique<Spaceship>()),
        s2(std::make_unique<Spaceship>());
    // note: types partially erased

    collideWith(*a1, *a2); // Asteroid-Asteroid collision
    collideWith(*a1, *s1); // Asteroid-Spaceship collision
    collideWith(*s1, *a1); // Spaceship-Asteroid collision
    collideWith(*s1, *s2); // Spaceship-Spaceship collision

    return 0;
}

स्ट्रॉस्ट्रुप ने सी++ के डिजाइन और विकास में उल्लेख किया है कि उन्हें मल्टीमेथ्स की अवधारणा पसंद आई और इसे सी++ में प्रयुक्त करने पर विचार किया गया था, लेकिन दावा किया गया कि वे एक कुशल नमूना कार्यान्वयन आभासी कार्यों की तुलना में और कुछ संभावित प्रकार की एम्बिगुइटी समस्याओं को हल करने में असमर्थ रहे हैं। उसके बाद उन्होंने कहा कि चूंकि यह सुविधा अभी भी अच्छी है और इस प्रकार इसे दोहरा प्रेषण या टाइप आधारित लुकअप टेबल का उपयोग करके प्रयुक्त किया जा सकता है, जैसा कि ऊपर C/C++ उदाहरण में उल्लिखित है, इसलिए यह भविष्य के लैंग्वेज संशोधनों के लिए एक कम प्राथमिकता वाली विशेषता है।[20]

डी

2021 तक, कई अन्य ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज की तरह उपयोग करते हैं, D प्रोग्रामिंग लैंग्वेज मूल रूप से केवल सिंगल प्रेषण का समर्थन करता है। चूंकि, डी में लाइब्रेरी फ़ंक्शन के रूप में ओपन मल्टीमेथड्स का अनुकरण करना संभव है। [21] ओपनमेथड्स लाइब्रेरी का एक उदाहरण है। 

// Declaration
Matrix plus(virtual!Matrix, virtual!Matrix);

// The override for two DenseMatrix objects
@method
Matrix _plus(DenseMatrix a, DenseMatrix b)
{
  const int nr = a.rows;
  const int nc = a.cols;
  assert(a.nr == b.nr);
  assert(a.nc == b.nc);
  auto result = new DenseMatrix;
  result.nr = nr;
  result.nc = nc;
  result.elems.length = a.elems.length;
  result.elems[] = a.elems[] + b.elems[];
  return result;
}

// The override for two DiagonalMatrix objects
@method
Matrix _plus(DiagonalMatrix a, DiagonalMatrix b)
{
  assert(a.rows == b.rows);
  double[] sum;
  sum.length = a.elems.length;
  sum[] = a.elems[] + b.elems[];
  return new DiagonalMatrix(sum);
}


जावा

केवल एकल प्रेषण वाली लैंग्वेज में होता है, जैसे कि जावा (प्रोग्रामिंग लैंग्वेज ) एकाधिक प्रेषण को एकल प्रेषण के कई स्तरों के साथ अनुकरण किया जा सकता है

UML class Java single dispatch.svg 

interface Collideable {
    void collideWith(final Collideable other);

    /* These methods would need different names in a language without method overloading. */
    void collideWith(final Asteroid asteroid);
    void collideWith(final Spaceship spaceship);
}

class Asteroid implements Collideable {
    public void collideWith(final Collideable other) {
        // Call collideWith on the other object.
        other.collideWith(this);
   }

    public void collideWith(final Asteroid asteroid) {
        // Handle Asteroid-Asteroid collision.
    }

    public void collideWith(final Spaceship spaceship) {
        // Handle Asteroid-Spaceship collision.
    }
}

class Spaceship implements Collideable {
    public void collideWith(final Collideable other) {
        // Call collideWith on the other object.
        other.collideWith(this);
    }

    public void collideWith(final Asteroid asteroid) {
        // Handle Spaceship-Asteroid collision.
    }

    public void collideWith(final Spaceship spaceship) {
        // Handle Spaceship-Spaceship collision.
    }
}

रन टाइम समय instanceof एक या दोनों स्तरों पर जाँचों का भी उपयोग किया जाता है।

प्रोग्रामिंग लैंग्वेज में समर्थन

प्राथमिक प्रतिमान

  • जूलिया (प्रोग्रामिंग लैंग्वेज )[22]


सामान्य मल्टीमेथ्स का समर्थन


एक्सटेंशन के माध्यम से

यह भी देखें

संदर्भ

  1. ↑ Ranka, Sanjay; Banerjee, Arunava; Biswas, Kanad Kishore; Dua, Sumeet; Mishra, Prabhat; Moona, Rajat (2010-07-26). Contemporary Computing: Second International Conference, IC3 2010, Noida, India, August 9–11, 2010. Proceedings. Springer. ISBN 9783642148248.
  2. ↑ 2.00 2.01 2.02 2.03 2.04 2.05 2.06 2.07 2.08 2.09 2.10 Muschevici, Radu; Potanin, Alex; Tempero, Ewan; Noble, James (2008). अभ्यास में एकाधिक प्रेषण. pp. 563–582. doi:10.1145/1449764.1449808. ISBN 9781605582153. S2CID 7605233. {{cite book}}: |journal= ignored (help)
  3. ↑ 3.0 3.1 3.2 3.3 3.4 Bezanson, Jeff; Edelman, Alan; Karpinski, Stefan; Shah, Viral B. (7 February 2017). "Julia: A fresh approach to numerical computing". SIAM Review. 59 (1): 65–98. arXiv:1411.1607. doi:10.1137/141000671. S2CID 13026838.
  4. ↑ Castagna, Giuseppe; Ghelli, Giorgio & Longo, Giuseppe (1995). "उपप्रकार के साथ अतिभारित कार्यों के लिए एक कलन". Information and Computation. 117 (1): 115–135. doi:10.1006/inco.1995.1033. Retrieved 2013-04-19.
  5. ↑ Castagna, Giuseppe (1996). Object-Oriented Programming: A Unified Foundation. Progress in Theoretical Computer Science. Birkhäuser. p. 384. ISBN 978-0-8176-3905-1.
  6. ↑ Castagna, Giuseppe (1995). "Covariance and contravariance: conflict without a cause". ACM Transactions on Programming Languages and Systems. 17 (3): 431–447. CiteSeerX 10.1.1.115.5992. doi:10.1145/203095.203096. S2CID 15402223.
  7. ↑ Bruce, Kim; Cardelli, Luca; Castagna, Giuseppe; Leavens, Gary T.; Pierce, Benjamin (1995). "बाइनरी विधियों पर". Theory and Practice of Object Systems. 1 (3): 221–242. doi:10.1002/j.1096-9942.1995.tb00019.x. Retrieved 2013-04-19.
  8. ↑ "Using type dynamic (C# Programming Guide)". Retrieved 2020-05-14.
  9. ↑ "Basic concepts". Retrieved 2020-05-14.
  10. ↑ "Dynamic .NET - Understanding the Dynamic Keyword in C# 4". Retrieved 2020-05-14.
  11. ↑ Groovy - Multi-methods
  12. ↑ @arrows/multimethod Maciej Cąderek द्वारा कॉन्फ़िगर करने योग्य डिस्पैच रिज़ॉल्यूशन के साथ JavaScript/TypeScript में एकाधिक प्रेषण।
  13. ↑ Coady, Aric, multimethod: Multiple argument dispatching., retrieved 2021-01-28
  14. ↑ "PEAK-Rules 0.5a1.dev". Python Package Index. Retrieved 21 March 2014.
  15. ↑ "PyProtocols". Python Enterprise Application Kit. Retrieved 26 April 2019.
  16. ↑ "रेग". Read the docs. Retrieved 26 April 2019.
  17. ↑ "C Object System: A framework that brings C to the level of other high level programming languages and beyond: CObjectSystem/COS". GitHub. 2019-02-19.
  18. ↑ "C++ के लिए मल्टी-मेथड्स और ओपन-मेथड्स के लिए लैंग्वेज सपोर्ट पर रिपोर्ट" (PDF). 2007-03-11. Multiple dispatch – the selection of a function to be invoked based on the dynamic type of two or more arguments – is a solution to several classical problems in object-oriented programming.{{cite web}}: CS1 maint: url-status (link)
  19. ↑ yomm2, Fast, Orthogonal Open Multi-Methods for C++ by Jean-Louis Leroy.
  20. ↑ Stroustrup, Bjarne (1994). "Section 13.8". सी ++ का डिजाइन और विकास. Indianapolis, IN, U.S.A: Addison Wesley. Bibcode:1994dec..book.....S. ISBN 978-0-201-54330-8.
  21. ↑ openmethods, Open Multi-Methods for D by Jean-Louis Leroy.
  22. ↑ "Methods". The Julia Manual. Julialang. Archived from the original on 17 July 2016. Retrieved 11 May 2014.
  23. ↑ "Multimethods in C# 4.0 With 'Dynamic'". Retrieved 2009-08-20.
  24. ↑ "Cecil Language". Retrieved 2008-04-13.
  25. ↑ "Multimethods in Clojure". Retrieved 2008-09-04.
  26. ↑ Steele, Guy L. (1990). "28". Common LISP: The Language. Bedford, MA, U.S.A: Digital Press. ISBN 978-1-55558-041-4.
  27. ↑ "Background and Goals". Retrieved 2008-04-13.
  28. ↑ "Elixir Lang | Getting Started | Modules and functions". Retrieved 2017-11-10.
  29. ↑ "The Fortress Language Specification, Version 1.0" (PDF). Archived from the original (PDF) on 2013-01-20. Retrieved 2010-04-23.
  30. ↑ "Multimethods in Groovy". Retrieved 2008-04-13.
  31. ↑ "Methods – LassoGuide 9.2". Retrieved 2014-11-11.
  32. ↑ "Visitor Pattern Versus Multimethods". Retrieved 2008-04-13.
  33. ↑ "Nim Manual: Multi-methods". Retrieved 2022-05-03.
  34. ↑ "Perl 6 FAQ". Retrieved 2008-04-13.
  35. ↑ "How S4 Methods Work" (PDF). Retrieved 2008-04-13.
  36. ↑ "Multiple Dispatch in Seed7". Retrieved 2011-04-23.
  37. ↑ "TADS 3 System Manual". Retrieved 2012-03-19.
  38. ↑ "VB.Net Multiple Dispatch". Retrieved 2020-03-31.
  39. ↑ "New Features in C#4.0 and VB.Net 10.0". 4 November 2010. Retrieved 2020-03-31.
  40. ↑ "Notes for Programming Language Experts". Retrieved 2016-08-21.
  41. ↑ "Multiple dispatch".


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=एकाधिक_प्रेषण&oldid=214715’