Как указать универсальную функцию, которая работает так, как будто есть супертип Int, Double и т. Д.?

Question

Мне нужно определить класс, который гарантирует наличие основных числовых операций (+, -, *, ...)

def Arithmetic[T <: AnyVal](a: T, b: T) {
   val x = a + b
}

AnyVal не определяет+.Вторая попытка:

import Numeric.implicits._

def Arithmetic[T <% Numeric](a: T, b: T) {
   val x = a + b
}

Пока все хорошо, но теперь я заставляю T быть того же типа.Следовательно, Arithmetic(double, int) потерпит неудачу.Мое реальное приложение даже немного более изобретательно:

class Arithmetic[T](A: Connector[T], B: Connector[U])(implicit n: Numeric[T]) {   
  val sum  = new Connector({ n.plus(A.value + B.value) })
}

class Constant[T](var x: T) {
  val value = new Connector({ x })
}

class Connector[T](f: => T) {
  def value: T = f
  override def toString = value.toString()
}

Теперь для использования:

object Main extends App {
  val n1 = new Constant(1)

  // works
  val n5 = new Constant(5)
  val a = new Arithmetic( n1.value, n5.value )

  // doesn't work
  val n55 = new Constant(5.5)
  val b = new Arithmetic( n1.value, n55.value )
}

Мысли?Предложения?Мне просто нужно что-то, что гарантирует, что я могу выполнять основные математические операции внутри этого класса ...

Answer 1

Думаю, вы должны использовать границы контекста здесь

def arithmetic[T: Numeric](a: T, b: T) = {
  import Numeric.Implicits._
  a + b
}

это работает, по крайней мере, для scala 2.9.1

scala> arithmetic(1, 2.2)
res0: Double = 3.2

Answer 2

Вот идея:

class BiConverter[T, U, That](val toThat1: T => That, val toThat2: U => That)(implicit val num: Numeric[That])

trait LowPriorityBiConverterImplicits {
  implicit def subtype[A: Numeric, T <: A, U <: A]: BiConverter[T, U, A] = new BiConverter[T, U, A](identity, identity)
}

object BiConverter extends LowPriorityBiConverterImplicits {
  implicit def identityConverter[T: Numeric]: BiConverter[T, T, T] = new BiConverter[T, T, T](identity, identity)
  implicit def firstAsSecond[T, U](implicit conv: T => U, num: Numeric[U]): BiConverter[T, U, U] = new BiConverter[T, U, U](conv, identity)
  implicit def secondAsFirst[T, U](implicit conv: U => T, num: Numeric[T]): BiConverter[T, U, T] = new BiConverter[T, U, T](identity, conv)
}

class Arithmetic[T] private (A: Connector[T], B: Connector[T])(implicit n: Numeric[T]) {
  import Numeric.Implicits._
  val sum = new Connector(A.value + B.value)
}
object Arithmetic {
  def apply[T, U, That](A: Connector[T], B: Connector[U])(implicit conv: BiConverter[T, U, That], tIsThatEvidence: T =:= That = null, uIsThatEvidence: U =:= That = null): Arithmetic[That] = {
    val newA: Connector[That] =
      if (tIsThatEvidence != null) A.asInstanceOf[Connector[That]]
      else new Connector(conv.toThat1(A.value))
    val newB: Connector[That] =
      if (uIsThatEvidence != null) B.asInstanceOf[Connector[That]]
      else new Connector(conv.toThat2(B.value))
    new Arithmetic(newA, newB)(conv.num)
  }
}
class Constant[T](var x: T) {
  val value = new Connector(x)
}

class Connector[T](f: => T) {
  def value: T = f
  override def toString = value.toString()
}

Использование:

val n1 = new Constant(1)

val n5 = new Constant(5)
val a = Arithmetic(n1.value, n5.value)
val sum1 = a.sum.value // Int
println(sum1)

val n55 = new Constant(5.5)
val b = Arithmetic(n1.value, n55.value)
val sum2 = b.sum.value // Double
println(sum2)

val nBig5 = new Constant(BigInt(5))
val c = Arithmetic(n1.value, nBig5.value)
val sum3 = c.sum.value // BigInt
println(sum3)

Answer 3

Хотелось бы что-нибудь подобное для вас?

import Numeric.Implicits._

trait Add[A, B, Result] {
  def plus(a: A, b: B): Result
}

trait LowerPriorityAdd {
  implicit def addNumNum[M, N](implicit numM: Numeric[M], numN: Numeric[N]) = new Add[M, N, Double] {
    def plus(m: M, n: N) = m.toDouble + n.toDouble
  }
}

trait LowPriorityAdd {
  implicit def addYX[X, Y, Z](implicit addXY: Add[X, Y, Z]) = new Add[Y, X, Z] {
    def plus(y: Y, x: X) = addXY.plus(x, y)
  }
}

object Add extends LowPriorityAdd with LowerPriorityAdd {
  implicit object AddIntInt extends Add[Int, Int, Int] {
    def plus(i: Int, j: Int) = i + j
  }

  implicit object AddIntDouble extends Add[Int, Double, Double] {
    def plus(i: Int, d: Double) = i + d
  }
}

class Arithmetic[T, U, V](t: Connector[T], u: Connector[U])(implicit ev: Add[T, U, V]) {
  val sum: Connector[V] = new Connector(ev.plus(t.value, u.value))
}

class Constant[A](val x: A) {
  val value: Connector[A] = new Connector(x)
}

class Connector[A](f: => A) {
  def value: A = f
  override def toString = value.toString
}

def main(args: Array[String]): Unit = {
  val n1 = new Constant(1)

  // works
  val n5 = new Constant(5)
  val a = new Arithmetic( n1.value, n5.value )

  // works
  val n55 = new Constant(5.5)
  val b = new Arithmetic( n1.value, n55.value )

  // works
  val c = new Arithmetic(n55.value, n1.value)
}