वैल्यू [टी: न्यूमेरिक] "अनबॉक्स किए गए" समकक्षों की तरह अधिक "लचीला" का उपयोग करके कोड कैसे बनाएं?

Question

यदि मेरे पास 5 * 5.0 जैसे कोड हैं तो परिणाम सबसे सटीक प्रकार, Double में परिवर्तित हो जाता है।

लेकिन इस तरह

case class Value[T : Numeric](value: T) { 
    type This = Value[T] 
    def +(m: This) = Value[T](implicitly[Numeric[T]].plus(value, m.value)) 
    ... 
} 

implicit def numToValue[T : Numeric](v: T) = Value[T](v) 

कोड के साथ काम नहीं लगता है वहाँ someIntValue + double काम तरह बातें करने के लिए एक रास्ता है, जहां someIntValueValue[Int] और doubleDouble है?

पीएस: बहुत कम से कम सही शीर्षक के लिए खेद है। मैं बेहतर शब्दों के लिए सुझाव के लिए आभारी हूँ ...

Answer 1

आप बनाने निहित ऑपरेटरों द्वारा (busywork का एक बहुत के साथ) कर सकते हैं:

abstract class Arith[A,B,C] { 
    def +(a: A, b: B): C 
    def -(a: A, b: B): C 
    def *(a: A, b: B): C 
    def /(a: A, b: B): C 
} 
implicit object ArithIntLong extends Arith[Int,Long,Long] { 
    def +(a: Int, b: Long) = a+b 
    def -(a: Int, b: Long) = a-b 
    def *(a: Int, b: Long) = a*b 
    def /(a: Int, b: Long) = a/b 
} 
... 
def f[A,B,C](a: A, b: B)(implicit arith: Arith[A,B,C]) = arith.*(a,b) 


scala> f(5,10L) 
res46: Long = 50 

लेकिन तुम सच में के बाद से है कि अधिक से अधिक करने के लिए, है आपको अकेले ए और बी के लिए संख्यात्मक समकक्ष की आवश्यकता है, और असममित परिचालनों को दोनों तरीकों से परिभाषित करने की आवश्यकता है। और यह वास्तव में व्यावहारिक नहीं है कि तीन प्रकार शामिल हैं।