Как настроить неявное преобразование, чтобы разрешить арифметику между числовыми типами?

Я хотел бы реализовать класс C для хранения значений различных числовых типов, а также булевых. Кроме того, я хотел бы иметь возможность работать с экземплярами этого класса, между типами, преобразовывать, где необходимо, Int --> Double и Boolean -> Int, т.е. Иметь возможность добавлять Boolean + Boolean, Int + Boolean, Boolean + Int, Int + Double, Double + Double и т.д., возвращая наименьший возможный тип (Int или Double), когда это возможно.

До сих пор я придумал это:

abstract class SemiGroup[A] { def add(x:A, y:A):A }

class C[A] (val n:A) (implicit val s:SemiGroup[A]) {
  def +[T <% A](that:C[T]) = s.add(this.n, that.n)
}

object Test extends Application {
  implicit object IntSemiGroup extends SemiGroup[Int] { 
    def add(x: Int, y: Int):Int = x + y 
  }

  implicit object DoubleSemiGroup extends SemiGroup[Double] { 
    def add(x: Double, y: Double):Double = x + y 
  }

  implicit object BooleanSemiGroup extends SemiGroup[Boolean] { 
    def add(x: Boolean, y: Boolean):Boolean = true;
  }

  implicit def bool2int(b:Boolean):Int = if(b) 1 else 0

  val n = new C[Int](10)
  val d = new C[Double](10.5)
  val b = new C[Boolean](true)

  println(d + n)    // [1]
  println(n + n)    // [2]
  println(n + b)    // [3]
  // println(n + d)    [4] XXX - no implicit conversion of Double to Int exists
  // println(b + n)    [5] XXX - no implicit conversion of Int to Boolean exists
}

Это работает для некоторых случаев (1, 2, 3), но не для (4, 5). Причина в том, что существует неявное расширение типа от более низкого к более высокому, но не к другому. В некотором смысле метод

def +[T <% A](that:C[T]) = s.add(this.n, that.n)

как-то должен быть метод партнера, который будет выглядеть примерно так:

def +[T, A <% T](that:C[T]):T = that.s.add(this.n, that.n)

но это не скомпилировано по двум причинам: во-первых, компилятор не может преобразовать this.n в тип T (хотя мы указываем ограничение представления A <% T), и, во-вторых, даже если бы он мог конвертировать this.n, после стирания типа два метода + становятся двусмысленными.

Жаль, что это так долго. Любая помощь приветствуется! В противном случае мне кажется, что я должен явно выписать все операции между всеми типами. И получилось бы волосатое, если бы мне пришлось добавлять дополнительные типы (Complex следующий в меню...).

Может, у кого-то есть еще один способ добиться всего этого? Чувствует, что там что-то простое, я не замечаю.

Спасибо заранее!

Ответ 1

Хорошо, Даниэль!

Я ограничил решение игнорировать Boolean и работает только с AnyVals, у которого есть слабая наименее верхняя граница, у которой есть экземпляр Numeric. Эти ограничения произвольны, вы можете удалить их и закодировать свои собственные слабые отношения соответствия между типами - реализация a2b и a2c может выполнять некоторое преобразование.

Интересно рассмотреть, как неявные параметры могут имитировать наследование (передавая неявные параметры типа (Derived = > Base) или Weak Conformance. Они действительно мощные, особенно когда тип inferencer помогает вам.

Во-первых, нам нужен класс типа для представления наименьшей верхней верхней границы всех пар типов A и B, которые нас интересуют.

sealed trait WeakConformance[A <: AnyVal, B <: AnyVal, C] {
  implicit def aToC(a: A): C

  implicit def bToC(b: B): C
}

object WeakConformance {
  implicit def SameSame[T <: AnyVal]: WeakConformance[T, T, T] = new WeakConformance[T, T, T] {
    implicit def aToC(a: T): T = a

    implicit def bToC(b: T): T = b
  }

  implicit def IntDouble: WeakConformance[Int, Double, Double] = new WeakConformance[Int, Double, Double] {
    implicit def aToC(a: Int) = a

    implicit def bToC(b: Double) = b
  }

  implicit def DoubleInt: WeakConformance[Double, Int, Double] = new WeakConformance[Double, Int, Double] {
    implicit def aToC(a: Double) = a

    implicit def bToC(b: Int) = b
  }

  // More instances go here!


  def unify[A <: AnyVal, B <: AnyVal, C](a: A, b: B)(implicit ev: WeakConformance[A, B, C]): (C, C) = {
    import ev._
    (a: C, b: C)
  }
}

Метод unify возвращает тип C, который вычисляется индексом типа на основе доступности неявных значений для предоставления в качестве неявного аргумента ev.

Мы можем подключить это в ваш класс-оболочку C следующим образом, также требуя Numeric[WeakLub], чтобы мы могли добавить значения.

case class C[A <: AnyVal](val value:A) {
  import WeakConformance.unify
  def +[B <: AnyVal, WeakLub <: AnyVal](that:C[B])(implicit wc: WeakConformance[A, B, WeakLub], num: Numeric[WeakLub]): C[WeakLub] = { 
    val w = unify(value, that.value) match { case (x, y) => num.plus(x, y)}; 
    new C[WeakLub](w)
  }
}

И, наконец, все вместе:

object Test extends Application {
  val n = new C[Int](10)
  val d = new C[Double](10.5)

  // The type ascriptions aren't necessary, they are just here to 
  // prove the static type is the Weak LUB of the two sides.
  println(d + n: C[Double]) // C(20.5)
  println(n + n: C[Int])    // C(20)
  println(n + d: C[Double]) // C(20.5)
}

Test

Ответ 2

Там , чтобы сделать это, но я оставлю его retronym, чтобы объяснить это, так как он написал это решение.: -)