Generic numerical operations.

abstract class NumericCombine[A: Numeric, B: Numeric] {
    type AB <: AnyVal

    def fromA(x: A): AB
    def fromB(y: B): AB
    val num: Numeric[AB]

    def plus(x: A, y: B): AB = num.plus(fromA(x), fromB(y))
    def minus(x: A, y: B): AB = num.minus(fromA(x), fromB(y))
    def times(x: A, y: B): AB = num.times(fromA(x), fromB(y))
}

abstract class NumericCombineImpl[A: Numeric, B: Numeric, R <: AnyVal]
(implicit override val num: Numeric[R])
    extends NumericCombine[A, B] {
    type AB = R
}

abstract class NumericCombineImpl2[A<: AnyVal]
        (implicit override val num: Numeric[A])
            extends NumericCombine[A, A] {
            type AB = A
            override def fromA(x: A): A = x
            override def fromB(y: A): A = y
}

object implicits {

    implicit object IntFloat extends NumericCombineImpl[Int, Float, Float] {
        override def fromA(x: Int): AB = x.toFloat
        override def fromB(y: Float): AB = y
    }

    implicit object FloatInt extends NumericCombineImpl[Float, Int, Float] {
        override def fromA(x: Float): Float = x
        override def fromB(y: Int): Float = y.toFloat
    }

    implicit object IntInt extends NumericCombineImpl2[Int]
}

object NumericOps{
    def plus[A: Numeric, B: Numeric](x: A, y: B)(implicit ev: NumericCombine[A, B])
    : ev.AB = ev.plus(x, y)
}