स्कैला: जावा, सी #, स्कैला और सी ++

Question

में उच्च प्रकार के, खुले प्रकार के और जंगली कार्ड जेनेरिक, मैं सी # में प्रोग्रामिंग कर रहा था, लेकिन इसकी टाइप सिस्टम की सीमाओं से निराश था। पहली बातों में से एक, मैंने स्कैला के बारे में सीखा था कि स्कैला में उच्च प्रकार की जेनेरिक है। लेकिन जब भी मैंने कई लेखों, ब्लॉग प्रविष्टियों और प्रश्नों को देखा, तब भी मुझे यकीन नहीं था कि उच्च प्रकार के जेनेरिक क्या थे। वैसे भी मैंने कुछ स्कैला कोड लिखा था जो ठीक संकलित, क्या यह स्निपेट उच्च प्रकार का उपयोग करता है?

abstract class Descrip [T <: DTypes, GeomT[_ <: DTypes] <: GeomBase[_]](newGeom: NewGeom[GeomT]) 
{ 
    type GeomType = GeomT[T] 
    val geomM: GeomT[T] = newGeom.apply[T]() 
} 

और फिर मैं शायद सोचा था कि मैं पहले से ही उच्च kinded जेनरिक उपयोग कर रहा हूँ। जैसा कि मैं समझता हूं कि मैं था, लेकिन तब जब मैं अब समझ गया था कि मैं पहले से ही स्काला के बारे में भी सुना था, मैं पहले से ही उच्च प्रकार के प्रकारों का उपयोग कर रहा था। क्या यह स्निपेट उच्च प्रकार के प्रकार का उपयोग करता है?

namespace ConsoleApplication3 
{ 
    class Class1<T> 
    { 
     List<List<T>> listlist; 
    } 
} 

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

तो क्या निम्न सही है? इस तालिका में एलेक्सी का जवाब

Lang: Higher-kind Wild-card Open-types 

Scala yes   yes  yes 

C#  no   no  no 

Java  no   yes  no 

C++  yes   yes  yes 

Answer 1

यह उच्च kinded प्रकार है के लिए सही किया गया है यह नहीं है:

नहीं, एक उच्च kinded प्रकार है

class Class1<T> 
{ 
    T<String> foo; // won't compile in actual C# 
} 

की तरह कुछ अर्थात एक सामान्य प्रकार जिसका पैरामीटर सामान्य होने के लिए आवश्यक है। ध्यान दें कि इस उदाहरण में Class1<IList> संकलित करना चाहिए, लेकिन Class1<String> या Class1<IDictionary> नहीं होना चाहिए।

Answer 2

ऐसा लगता है कि आपको यह समझने की आवश्यकता है कि उच्च प्रकार के प्रकार क्या हैं, और वे उपयोगी क्यों हैं।

पर विचार करें निम्नलिखित इंटरफेस (जावा, F<X,Y> बंद स्थानापन्न के रूप में प्रयोग किया जाता है):

interface ListFun { 
    public <A,B> List<B> fmap(F<A,B> fn, List<A> list); 
} 

interface SetFun { 
    public <A,B> Set<B> fmap(F<A,B> fn, Set<A> set); 
} 

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

यह कैसा दिखना चाहिए? आप परीक्षा तरह

interface Fun<X> { 
    public <A,B> X<B> fmap(F<A,B> fn, X<A> col); 
} 

class ListFun implements Fun<List> {...} 

लेकिन X<A> कुछ लिखने के लिए जावा या सी # की अनुमति नहीं है, अगर XList की तरह एक निश्चित प्रकार की नहीं है होगा, लेकिन एक प्रकार पैरामीटर। लेकिन अगर इस अवशोषण को किसी तरह से अनुमति दी जाती है (जैसे स्कैला या हास्केल में), तो आपके पास उच्च प्रकार के प्रकार होते हैं (या "उच्च क्रम प्रकार बहुरूपता", शब्दावली अभी भी इसके लिए अस्पष्ट है)।यहां स्कैला विशेषता और कार्यान्वयन है:

trait Fun[X[_]] { 
    def fmap[A,B](fn: A => B, col:X[A]):X[B] 
} 

class ListFun extends Fun[List]{ 
    def fmap[A,B](fn: A => B, list: List[A]) = list.map(fn) 
} 

यह मूल विचार है। आम तौर पर आपको अक्सर इस सामान की आवश्यकता नहीं होती है, लेकिन जब आपको इसकी आवश्यकता होती है, तो यह अविश्वसनीय उपयोगी हो सकता है।