¿Cómo hacer código usando Value [T: Numeric] más "flexible" como las contrapartidas "unboxed"?

Question

Si tengo un código como 5 * 5.0, el resultado se convierte al tipo más preciso, Double.

Pero esto no parece funcionar con un código como

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) 

¿Hay una manera de hacer las cosas como someIntValue + double trabajo, donde es someIntValueValue[Int] y double es Double?

PD: Perdón por el título menos que perfecto. Estoy agradecido por las sugerencias para una mejor redacción ...

Answer 1

Usted puede hacer esto (con una gran cantidad de trabajo no productivo) mediante la creación de operadores implícitos:

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 

pero que realmente tienen que hacer más que eso, ya necesita un equivalente numérico para A y B solo, y las operaciones asimétricas deben definirse en ambos sentidos. Y no es realmente práctico especializarse dado que hay tres tipos involucrados.