स्कैला में @uncheckedVariance की आवश्यकता कब है, और इसका उपयोग जेनेरिक ट्रेवरेबल टेम्पलेट में क्यों किया जाता है?

Question

@uncheckedVariance का उपयोग स्कैला की घोषणा साइट भिन्नता एनोटेशन और जावा के इनवेरिएंट जेनेरिक के बीच के अंतर को पुल करने के लिए किया जा सकता है।

scala> import java.util.Comparator  
import java.util.Comparator 

scala> trait Foo[T] extends Comparator[T] 
defined trait Foo 

scala> trait Foo[-T] extends Comparator[T]  
<console>:5: error: contravariant type T occurs in invariant position in type [-T]java.lang.Object with java.util.Comparator[T] of trait Foo 
     trait Foo[-T] extends Comparator[T] 
      ^

scala> import annotation.unchecked._  
import annotation.unchecked._ 

scala> trait Foo[-T] extends Comparator[T @uncheckedVariance]  
defined trait Foo 

यह कहना है कि java.util.Comparator स्वाभाविक रूप से विपरीत संस्करण है, उस प्रकार पैरामीटर T मानकों में और एक वापसी प्रकार में कभी नहीं दिखाई देता है।

यह सवाल पूछता है: इसका उपयोग स्कैला संग्रह पुस्तकालय में क्यों किया जाता है जो जावा इंटरफेस से विस्तारित नहीं होता है?

trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBuilder[A, CC[A] @uncheckedVariance] 

यह व्याख्या के लिए मान्य का उपयोग करता है क्या हैं?

Answer 1

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

जेनेरिक ट्रेवर्सबल टेम्पलेट के टाइपकेक को ए प्रकार पैरामीटर के लिए या तो कॉन्वर्सिस या इनवेरिएंस माना जाता है। हालांकि, जब हम इसे एक उत्परिवर्तनीय विशेषता में प्राप्त करते हैं, तो हमें आविष्कार करना होगा। इसके विपरीत, हम एक अपरिवर्तनीय उपclass में covariance पसंद करेंगे।

चूंकि हम जेनेरिक ट्रावर्सबल टेम्पलेट में भिन्नता एनोटेशन (अभी तक ;-)) पर अमूर्त नहीं कर सकते हैं, ताकि हम उप-वर्ग के आधार पर इसे किसी एक को तुरंत चालू कर सकें, हमें कास्टिंग का सहारा लेना होगा (@uncheckVariance अनिवार्य रूप से एक है तरह-कास्ट)। आगे पढ़ने के लिए, मैं अपने शोध प्रबंध की सलाह देते हैं (खेद ;-)) या हमारे हाल bitrot paper

Answer 2

मेरी थीसिस में मैं एक कलन, Scalina, तरह भाषा के हिस्से के रूप सीमा & विचरण में टिप्पणियां हैं कि वर्णन (किसी पुराने संस्करण भी है workshop paper के रूप में उपलब्ध)। इस चर्चा की प्रासंगिकता अगले चरण है जिसे मैं इस गणित को विकसित करने में लेना चाहता हूं: इसके ऊपर एक और परत बनाएं ताकि आप सीमाओं (आसान) और भिन्नता एनोटेशन (मेरे सिर स्पिन को बनाता है) पर सार लगा सकें। असल में, आप वहां केवल 1 अतिरिक्त परत नहीं लगाएंगे, बल्कि अपने बहुरूपता को सामान्यीकृत करेंगे ताकि वे सभी स्तरों पर काम कर सकें, और नियमित रूप से अपने "गुण" (सीमाएं, भिन्नता एनोटेशन, निहित तर्कों की आवश्यकता हो ...) विशेष प्रकार के साथ, जो सभी अमूर्तता के अधीन हैं।

विशिष्टता प्रकारों के संदर्भ में "गुण प्रकार हैं" विचार को एडस्को डी वेरी द्वारा अच्छी तरह से समझाया गया है।

Uniqueness Typing Simplified, Edsko डे व्रीज़, Rinus Plasmeijer, और डेविड अब्राहमसन। ओलाफ Chitil, Zoltán Horváth और विक्टोरिया Zsók (सं।) में:। आईएफएल 2007, LNCS 5083, पीपी 201-218, 2008

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

Answer 3

मैं एक समय जहां @uncheckedVariance प्रयोग किया जाता है पाया - सिंथेटिक विधि है कि एक सार प्रकार की एक पैरामीटर के लिए डिफ़ॉल्ट मान देता है:

M:\>scala -Xprint:typer -e "class C { def p[T >: Null](t: T = null) = t }" 
[[syntax trees at end of typer]]// Scala source: (virtual file) 
package <empty> { 
    final object Main extends java.lang.Object with ScalaObject { 
    def this(): object Main = { 
     Main.super.this(); 
    () 
    }; 
    def main(argv: Array[String]): Unit = { 
     val args: Array[String] = argv; 
     { 
     final class $anon extends scala.AnyRef { 
      def this(): anonymous class $anon = { 
      $anon.super.this(); 
      () 
      }; 
      class C extends java.lang.Object with ScalaObject { 
      <synthetic> def p$default$1[T >: Null <: Any]: Null @scala.annotation.unchecked.uncheckedVariance = null; 
      def this(): this.C = { 
       C.super.this(); 
      () 
      }; 
      def p[T >: Null <: Any](t: T = null): T = t 
      } 
     }; 
     { 
      new $anon(); 
     () 
     } 
     } 
    } 
    }