बांझ प्रकार के "स्वीकार्य जटिलता" पर स्केला को किस सीमा तक जगह मिलती है?

Question

के अनुसार स्काला भाषा युक्ति :

... स्थानीय प्रकार के अनुमानों की अनुमानित सीमा [प्रकार के मापदंडों] की जटिलता को सीमित करने की अनुमति है। प्रकार की न्यूनतमता और अधिकतमता को स्वीकार्य जटिलता के प्रकार के सापेक्ष समझना होगा।

व्यवहार में क्या सीमाएँ हैं?

इसके अलावा, क्या अलग-अलग सीमाएं हैं जो पैरामीटर प्रकार की सीमाओं की तुलना में हीन अभिव्यक्ति प्रकारों पर लागू होती हैं, और वे सीमाएं क्या हैं?

Comments

इस ब्लॉग में इस विषय पर कुछ दिलचस्प चर्चा की गई है

— जमील

मैं यहाँ वर्णित scala-

— डेव एल।

मुझे यकीन नहीं है, लेकिन मुझे लगता है कि इसका मतलब है उदाहरण के लिए हमारे पास तार की एक सूची है और हम इसके लिए एक उदाहरण जोड़ रहे हैं। लौटाई गई अपरिवर्तनीय सूची अंततः "कोई भी" प्रकार की है। तो प्रकार की अधिकतमता

— जतिन

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

— केविन सीटेज़ ने

@ सचिन सच है। मुझे लगता है कि मुझे scala 2.9 में सबसे ज्यादा दिलचस्पी है, क्योंकि यह हाल ही में स्थिर है। लेकिन मुझे आश्चर्य है कि बदलाव कितना होगा।

— ओवेन

Answer 1

प्रकारों का उल्लेख करते समय, कंपाइलर को अक्सर प्रकारों की सूची के कम से कम ऊपरी सीमा (LUB) की गणना करने की आवश्यकता होती है। उदाहरण के लिए, के प्रकार if (cond) e1 else e1के प्रकार के एलयूबी है e1और e1।

ये प्रकार काफी बड़े हो सकते हैं, उदाहरण के लिए इसे REPL में आज़माएँ:

:type Map(1 -> (1 to 10), 2 -> (1 to 10).toList)
scala.collection.immutable.Map[Int,scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int] with Serializable{def reverse: scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]{def reverse: scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]; def dropRight(n: Int): scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]; def takeRight(n: Int): scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]; def drop(n: Int): scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]; def take(n: Int): scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]}; def dropRight(n: Int): scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]{def reverse: scala.collection.immutable.Seq[Int] with scala.collection.AbstractSeq[Int]; def dropRight(n: Int): scala.collection.immutable.Seq[Int]...

इस प्रतिबद्ध ने इस तरह के अनुमानों की गहराई को सीमित करने के लिए कुछ संन्यास की जाँच शुरू की।

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