स्कैला में "कमजोर अनुरूपता" की अवधारणा क्या है?

Question

मुझे हाल ही में "वीक कॉन्फॉर्मेंस" शब्द (स्टैक ओवरफ्लो उपयोगकर्ता retronym के जवाब How to set up implicit conversion to allow arithmetic between numeric types?) का जवाब मिला है।

यह क्या है?

Answer 1

3.5.3 कमजोर अनुरूपता स्काला एक अधिक सामान्य अनुरूपता संबंध का उपयोग करता है। एक प्रकार एस कमजोर एक प्रकार टी के अनुरूप है, लिखा एस <: डब्ल्यू टी , अगर एस <: टी या दोनों एस और टी आदिम संख्या प्रकार के होते हैं और एस निम्नलिखित आदेश में टी पहले होती है।

• बाइट <: _{डब्ल्यू} लघु
• बाइट <: _{डब्ल्यू} चरित्र
• लघु <: _{डब्ल्यू} इंट
• इंट <: _{डब्ल्यू} लांग
• लांग +०१२३८७०३९५४: _{डब्ल्यू} फ्लोट
• फ्लोट <: _{डबल डब्ल्यू}

एक कमजोर कम से कम ऊपरी बाध्य कमजोर अनुरूपता के संबंध में एक कम से कम ऊपरी बाध्य है।

इसका उपयोग कहां किया जाता है?

सशर्त अभिव्यक्ति के प्रकार के कमजोर कम से कम ऊपरी सीमा (§3.5.3) e2 और E3 के प्रकार के

है: एक बात के लिए, यह if भाव के प्रकार स्कैला 2.7.एक्स में, यह AnyVal टाइप करेगा, Int और Double की कम से कम ऊपरी सीमा। 2.8.x में, यह Double के रूप में टाइप करता है।

scala> if (true) 1 else 1d 
res0: Double = 1.0 

इसी

:

scala> try { 1 } catch { case _ => 1.0 } 
res2: Double = 1.0 

scala> (new {}: Any) match { case 1 => 1; case _ => 1.0 } 
res6: Double = 1.0 

scala> def pf[R](pf: PartialFunction[Any, R]): PartialFunction[Any, R] = pf 
pf: [R](pf: PartialFunction[Any,R])PartialFunction[Any,R] 

scala> pf { case 1 => 1; case _ => 1d } 
res4: PartialFunction[Any,Double] = <function1> 

एक अन्य जगह यह प्रयोग किया जाता है प्रकार निष्कर्ष में है:

scala> def foo[A](a1: A, a2: A): A = a1 
foo: [A](a1: A,a2: A)A 

scala> foo(1, 1d) 
res8: Double = 1.0 

scala> def foos[A](as: A*): A = as.head 
foos: [A](as: A*)A 

scala> foos(1, 1d) 
res9: Double = 1.0 

और भी सरल अंकीय को चौड़ा करने के लिए:

संख्यात्मक का प्रसार करना। ई एक आदिम संख्या प्रकार है जो कमजोर अनुरूप है (§3.5.3) अपेक्षित प्रकार, यह अपेक्षित प्रकार 6.26 अंतर्निहित रूपांतरण में से एक 97 अंकीय रूपांतरण तरीकों toShort, tochar, toInt उपयोग करने के लिए चौड़ी है , टूल्स, टूफ्लैट, टू 0 डबल§12.2.1 में परिभाषित किया गया। अपेक्षित प्रकार आदिम संख्यात्मक प्रकार बाइट, लघु या चार है, और अभिव्यक्ति ई उस प्रकार के श्रेणी में पूर्णांक शाब्दिक फिटिंग है, इसे उस प्रकार के समान शाब्दिक में परिवर्तित कर दिया गया है।

scala> 1: Double 
res10: Double = 1.0 

अद्यतन

के रूप में डेनियल ने कहा, कल्पना के बारे में जो प्रकार कमजोर अनुरूपता है गलत है। चलिए संकलक से खुद से पूछें:

scala> :power 
** Power User mode enabled - BEEP BOOP  ** 
** scala.tools.nsc._ has been imported  ** 
** New vals! Try repl, global, power  ** 
** New cmds! :help to discover them   ** 
** New defs! Type power.<tab> to reveal  ** 

scala> settings.maxPrintString = 10000 


scala> import global.definitions._ 
import global.definitions._ 

scala> (for{c1 <- ScalaValueClasses; 
     c2 <- ScalaValueClasses 
     isNSC = isNumericSubClass(c1, c2) 
     if isNSC 
    } yield ("isNumericSubClass (%s, %s) = %b" format (c1, c2, isNSC))).mkString("\n") 


res5: String = 
isNumericSubClass (class Byte, class Byte) = true 
isNumericSubClass (class Byte, class Short) = true 
isNumericSubClass (class Byte, class Int) = true 
isNumericSubClass (class Byte, class Long) = true 
isNumericSubClass (class Byte, class Float) = true 
isNumericSubClass (class Byte, class Double) = true 
isNumericSubClass (class Short, class Short) = true 
isNumericSubClass (class Short, class Int) = true 
isNumericSubClass (class Short, class Long) = true 
isNumericSubClass (class Short, class Float) = true 
isNumericSubClass (class Short, class Double) = true 
isNumericSubClass (class Int, class Int) = true 
isNumericSubClass (class Int, class Long) = true 
isNumericSubClass (class Int, class Float) = true 
isNumericSubClass (class Int, class Double) = true 
isNumericSubClass (class Long, class Long) = true 
isNumericSubClass (class Long, class Float) = true 
isNumericSubClass (class Long, class Double) = true 
isNumericSubClass (class Char, class Int) = true 
isNumericSubClass (class Char, class Long) = true 
isNumericSubClass (class Char, class Char) = true 
isNumericSubClass (class Char, class Float) = true 
isNumericSubClass (class Char, class Double) = true 
isNumericSubClass (class Float, class Float) = true 
isNumericSubClass (class Float, class Double) = true 
isNumericSubClass (class Double, class Double) = true 

Answer 2

स्काला लैंग कल्पना 2.8 के अनुसार:
http://www.scala-lang.org/archives/downloads/distrib/files/nightly/pdfs/ScalaReference.pdf

3.5.3 कमजोर अनुरूपता
कुछ स्थितियों में स्काला एक और अधिक genral अनुरूपता संबंध का उपयोग करता है। एक प्रकार एस कमजोर एक प्रकार टी के अनुरूप है, लिखित एस <: डब्ल्यू टी, यदि एस <: टी या दोनों एस और टी आदिम संख्या प्रकार हैं और एस निम्नलिखित क्रम में टी से पहले है।
बाइट <: डब्ल्यू लघु
बाइट <: डब्ल्यू चरित्र
लघु <: डब्ल्यू इंट
इंट <: डब्ल्यू लांग
लांग <: डब्ल्यू फ्लोट
फ्लोट <: डब्ल्यू डबल
एक कमजोर कम से कम ऊपरी बाध्य है कमजोर अनुरूपता के संबंध में कम से कम ऊपरी बाध्य।

Answer 3

Sandor's answer को पूरा करने के लिए, 2.8 में यह नई सुविधा अभी भी बेक्ड (और निश्चित) हो रही है।

this thread में, एसर एक बुरा पक्ष प्रभाव का खुलासा:

scala> val a= 10 
a: Int = 10 

scala> val b= 3 
b: Int = 3 

scala> if (b!=0) a/b else Double.NaN 
res0: Double = 3.0 

scala> def div1(a: Int, b: Int) = if (b!=0) a/b else Double.NaN 
div1: (a: Int,b: Int)Double 

scala> def div2(a: Int, b: Int): Double = if (b!=0) a/b else Double.NaN 
div2: (a: Int,b: Int)Double 

scala> div1(10,3) 
res1: Double = 3.0 

scala> div2(10,3) 
res2: Double = 3.3333333333333335 

दिलचस्प लगता है, क्योंकि परोक्ष पाया परिणाम प्रकार Double है और परिणाम 3.0 है।
डबल स्पष्ट रूप से दिया जाता है, तो परिणाम 3.33 है ...

this thread में, मार्टिन ओडर्स्की (जून 21 वीं) कहते हैं:

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

यह एक Int पर Float => Float अलावा विधि इष्ट Int => Int पद्धति पर अगर परिणाम प्रकार फ्लोट था।
मैं कमजोर अनुरूपता में अपने परिवर्तन में रूढ़िवादी होने की कोशिश कर रहा था जिसमें मुझे कमजोर अनुरूपता की आवश्यकता थी, जहां यह बिल्कुल जरूरी दिखता था।
लेकिन ऐसा लगता है कि रूढ़िवादी होने के कारण हम जिस समस्या को देख रहे हैं!

और फिर भी एक और स्काला आर सी रिहाई;)

---

this thread by Martin Odersky (June 22d) में पुष्टि:

:

तो वहाँ RC6 से अब तक तीन बार बदलने वाली RC7 हो जाएगा

val x: Double = 10/33.0 देगा,नहीं 210 - कि प्रतिगमन मैं उल्लेख किया गया था

[...]

[...]

यह है कि। हमारी प्राथमिकताओं को अब 2.8 जितनी जल्दी हो सके उतनी जल्दी रोल करना है, और साथ ही साथ (1) ऊपर वास्तव में खराब प्रतिक्रियाओं से बचें।

समयरेखा:

• हम एक और सप्ताह RC6 पर प्रतिक्रिया प्राप्त करने के लिए इंतजार करेंगे।
• हम अगले सप्ताह की शुरुआत में आरसी 7 को धक्का देंगे।
  यदि कोई और समस्या नहीं दिखती है तो आरसी 7 जारी होने के बाद 2.8 अंतिम 10-14 दिनों में बदल जाएगा।

(इसलिए इसने जुलाई 12, मेरा मानना ​​है कि है, लेकिन इस अनुमान मेरा अकेला है चारों ओर;)) कुछ स्थितियों में