आपको उच्च प्रकार की आवश्यकता क्यों है?

Question

कुछ भाषाओं में वर्गों और प्रकार मानकों के साथ काम करता है (जैसे के लिए अनुमति देते List<T>हैं जहां Tएक मनमाना प्रकार हो सकता है)। उदाहरण के लिए, आपके पास एक फ़ंक्शन हो सकता है जैसे:

List<S> Function<S, T>(List<T> list)

हालाँकि कुछ भाषाएँ इस अवधारणा को एक स्तर अधिक बढ़ा देती हैं, जिससे आपको हस्ताक्षर के साथ एक फ़ंक्शन मिल सकता है:

K<S> Function<K<_>, S, T>(K<T> arg)

जहाँ K<_>स्वयं एक प्रकार है जैसे List<_>कि एक प्रकार का पैरामीटर है। यह "आंशिक प्रकार" एक प्रकार के निर्माता के रूप में जाना जाता है।

मेरा सवाल यह है कि आपको इस क्षमता की आवश्यकता क्यों है? यह समझ में आता है कि एक प्रकार है List<T>क्योंकि सभी List<T>लगभग समान हैं, लेकिन सभी K<_>पूरी तरह से अलग हो सकते हैं। आपके पास एक हो सकता है Option<_>और एक List<_>सामान्य कार्यक्षमता नहीं है।

Comments

यहाँ कई अच्छे उत्तर दिए गए हैं: stackoverflow.com/questions/21170493/…

— इसका शानदार

@itsbruce विशेष रूप से, Functorलुइस कैसिलस के उत्तर में उदाहरण काफी सहज है। क्या आम है List<T>और क्या है Option<T>? यदि आप मुझे एक और एक फंक्शन T -> Sदेते हैं तो मैं आपको एक List<S>या एक दे सकता हूं Option<S>। उनके पास एक और बात है कि आप Tदोनों में से एक मूल्य प्राप्त करने का प्रयास कर सकते हैं ।

— डोभाल

@ डोभाल: आप पूर्व को कैसे करेंगे? इस हद तक कि किसी को बाद में दिलचस्पी है, मुझे लगता है कि दोनों प्रकार के कार्यान्वयन के द्वारा नियंत्रित किया जा सकता है IReadableHolder<T>।

— सुपरकैट

@supercat मेरा अनुमान है कि उन्हें लागू करने के लिए होता IMappable<K<_>, T>विधि के साथ K<S> Map(Func<T, S> f), के रूप में लागू करने IMappable<Option<_>, T>, IMappable<List<_>, T>। तो आपको K<T> : IMappable<K<_>, T>इसका कोई उपयोग करने के लिए विवश होना पड़ेगा ।

— ग्रेग्रोस

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

— इसका शानदार

Answer 1

चूंकि किसी और ने इस सवाल का जवाब नहीं दिया है, मुझे लगता है कि मैं इसे खुद जाने दूंगा। मैं थोड़ा दार्शनिक होने जा रहा हूँ।

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

ऑब्जेक्ट-ओरिएंटेड भाषाओं में, प्रकार वर्गों के आधार पर एक इंटरफ़ेस को संतुष्ट करते हैं। प्रत्येक वर्ग का अपना इंटरफ़ेस होता है, जिसे उसके प्रकार के भाग के रूप में परिभाषित किया जाता है। चूँकि सभी कक्षाएं List<T>समान इंटरफ़ेस साझा करती हैं, आप कोड लिख सकते हैं जो बिना किसी काम के काम करता है T। इंटरफ़ेस लागू करने का एक और तरीका एक विरासत की कमी है, और यद्यपि दोनों अलग-अलग लगते हैं, यदि आप इसके बारे में सोचते हैं तो वे समान हैं।

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

उदाहरण के लिए, टिप्पणी में उल्लेख किया है, हम देख सकते हैं Option<>और List<>के रूप में "mappable", अर्थ में अगर आप एक समारोह है, तो आप एक परिवर्तित कर सकते हैं कि Option<T>एक में Option<S>, या एक List<T>एक में List<S>। यह याद रखना कि कक्षाओं का उपयोग सीधे उच्च प्रकारों पर अमूर्त करने के लिए नहीं किया जा सकता है, हम इसके बजाय एक इंटरफ़ेस बनाते हैं:

IMappable<K<_>, T> where K<T> : IMappable<K<_>, T>

और फिर हम दोनों में इंटरफ़ेस को लागू List<T>करने और Option<T>के रूप में IMappable<List<_>, T>और IMappable<Option<_>, T>क्रमशः। हमने जो किया है, वह वास्तविक (गैर-उच्च-प्रकार) प्रकारों पर अवरोधों को लगाने के लिए उच्च-प्रकार के प्रकारों का उपयोग कर रहा है Option<T>और List<T>। यह स्काला में कैसे किया जाता है, हालांकि निश्चित रूप से स्काला में लक्षण, प्रकार चर, और अंतर्निहित पैरामीटर जैसी विशेषताएं हैं जो इसे अधिक अभिव्यंजक बनाते हैं।

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

class Mappable mp where
    map :: mp a -> mp b

यह सीधे एक (अनिर्दिष्ट) प्रकार पर रखा गया एक अवरोध है mpजो एक प्रकार का पैरामीटर लेता है, और इसे उस फ़ंक्शन के साथ जुड़ा होना चाहिए mapजो एक mp<a>में बदल जाता है mp<b>। फिर हम ऐसे कार्यों को लिख सकते हैं जो उच्च-प्रकार के प्रकारों को विवश करते हैं Mappableजैसे कि ऑब्जेक्ट-ओरिएंटेड भाषाओं में आप एक विरासत बाधा डाल सकते हैं। अच्छी तरह की।

चीजों को योग करने के लिए, उच्च-प्रकार के प्रकारों का उपयोग करने की आपकी क्षमता उन्हें विवश करने या उन्हें प्रकार की बाधाओं के भाग के रूप में उपयोग करने की आपकी क्षमता पर निर्भर करती है।

Comments

नौकरी बदलने में बहुत व्यस्त हैं लेकिन आखिरकार मुझे अपना जवाब लिखने के लिए कुछ समय मिल जाएगा। मुझे लगता है कि आप बाधाओं के विचार से विचलित हो गए हैं, हालांकि। उच्च प्रकार के प्रकारों का एक महत्वपूर्ण पहलू यह है कि वे कार्यों / व्यवहार को परिभाषित करने की अनुमति देते हैं जिन्हें किसी भी प्रकार पर लागू किया जा सकता है जिसे तार्किक रूप से योग्यता प्राप्त करने के लिए दिखाया जा सकता है। मौजूदा प्रकारों पर अवरोध लगाने से दूर, प्रकार की कक्षाएं (उच्चतर प्रकार के एक अनुप्रयोग) उनके साथ व्यवहार जोड़ते हैं।

— इसका मारब

मुझे लगता है कि यह शब्दार्थ का मुद्दा है। एक प्रकार वर्ग एक प्रकार के वर्ग को परिभाषित करता है। जब आप किसी फ़ंक्शन को इस तरह परिभाषित करते हैं (Mappable mp) => mp a -> mp b, तो आपने mpप्रकार वर्ग का सदस्य होने के लिए बाधा रखी है Mappable। जब आप एक प्रकार की घोषणा करते हैं जैसे कि Optionउदाहरण के लिए Mappable, आप उस प्रकार के व्यवहार को जोड़ते हैं। मुझे लगता है कि आप किसी भी प्रकार के दबाव के बिना स्थानीय स्तर पर उस व्यवहार का उपयोग कर सकते हैं, लेकिन फिर यह एक साधारण कार्य को परिभाषित करने से अलग नहीं है।

— ग्रिगोरोस

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

— ग्रेगोरोस

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

— इसका मारब