Generic Point Addition in Scala

Question

I'm trying to pimp the Tuple(2) class with addition and scala multiplication members, so that I can use them more easily as geometric 2D points. This is what I've got:

implicit class Point[+T: Numeric](val t: (T, T)) {
  import Numeric.Implicits._
  def _1 = t._1
  def _2 = t._2

  def +[V >: T](p: Point[V])(implicit ev: Numeric[V]) : (V,V) = 
    (ev.plus(t._1, p._1), ev.plus(t._2, p._2))
}

println((2, 3) + Point(5.0, 6.0))

This doesn't work (can't find ev) presumably because strictly speaking Float isn't a supertype of Int - but there doesn't actually seem to be a weak-conformance-bound operator, and leaving it out entirely means I can't use ev.plus anymore because it's expecting two values of the same type V, not one of T and one of V.

How can I properly implement this code?

score 1 · Accepted Answer · answered Feb 09 '18 at 09:22

You are absolutely right. The problem is that Numeric[T] doesn't allow one to mix types (V and T) according to it's signature: def plus(x: T, y: T): T.

You can either use/emulate this library: https://github.com/azavea/numeric. It does a lot of implicit gymnastics to allow mixed types to work.

It does exactly what you need:

EasyImplicits allows you to operate on mixed numeric types (e.g. T + U + Int).

Alternatively chose to use underlying Double type instead of T/V - I know that's not always great (loss of precision, etc).

You code still works with points that don't mix types which is not that bad, otherwise Double doesn't look that terrible since automatic conversion will happen anyway.

jwvh · Answer 2 · 2018-02-09T13:07:53.910

I believe that because the constructor parameter is a tuple, it complicates what should have been simple numeric widening. This covers many (most?) conversions.

implicit class Point[T: Numeric](a: (T, T)) {
  import Numeric.Implicits._
  val _1 = a._1
  val _2 = a._2

  def +(x: T, y: T) = add(_1, _2, x, y)

  def +[U: Numeric](x:U, y:U)(implicit ev: T => U) =
    add[U](ev(_1), ev(_2), x, y)

  def +[U: Numeric](b: Point[U])(implicit ev: T => U) =
    add[U](ev(_1), ev(_2), b._1, b._2)

  private def add[N: Numeric](a:N, b:N, c:N, d:N) = (a+c, b+d)
}

usage:

(1, 4) + (2.2, 4.4)         //res0: (Double, Double) = (3.2,8.4)
(2.1, 3.1) + (9, 2)         //res1: (Double, Double) = (11.1,5.1)
(1, 4) + Point((5.2, 6.2))  //res2: (Double, Double) = (6.2,10.2)
Point((2, 3)) + (4L, 5L)    //res3: (Long, Long) = (6,8)
Point((1.5, 2.9)) + (1, 1)  //res4: (Double, Double) = (2.5,3.9)

But it won't widen the elements of an existing Point passed as a parameter to the +() method.

(3.3, 4.5) + Point((1, 3))  //Error:No implicit view available from Double => Int.

Generic Point Addition in Scala

2 Answers2