How to specify a generic function that works as if there is a supertype of Int, Double, etc?

Question

I need to define a class that guarantees the basic numeric operations will be present (+, -, *, ...)

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

AnyVal does not define +. Second attempt:

import Numeric.implicits._

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

So far so good, but now I am forcing T to be of the same type. Hence Arithmetic(double, int) will fail. My real application is even a little more contrived:

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()
}

Now for the usage:

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 )
}

Thoughts? Suggestions? I just need something that guarantees I am able do basic math operations inside that class...

You don't need to write things like `({ x })`; `(x)` will do just fine. — Jean-Philippe Pellet, Nov 17 '11 at 20:33

score 3 · Answer 1 · edited May 23 '17 at 11:47

3

Think you should use context bounds here

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

it works, at least for scala 2.9.1

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

edited May 23 '17 at 11:47

Community

1
1

answered Oct 14 '11 at 10:49

4e6

10,696
4
52
62

that's different from the specification of the question – tiagoboldt Oct 14 '11 at 11:22
it's about the first part of question (the original one) :) – 4e6 Oct 14 '11 at 12:04

score 2 · Accepted Answer · answered Nov 17 '11 at 20:30

Here's an idea:

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()
}

Usage:

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)

Nice :-) You cracked my problem, although the solution seems so big and "inelegant"... Anyway, thank you. — Hugo Sereno Ferreira, Nov 18 '11 at 19:54
:-) The solution is similar to that used in the collections framework to determine the return type of a `map` operation with the `CanBuildFrom` implicit parameter. — Jean-Philippe Pellet, Nov 19 '11 at 10:41
@HugoSFerreira Will you be closing the bounty with this or are you looking for another answer? — Jean-Philippe Pellet, Nov 19 '11 at 14:00
I'll close the bounty on this, though I would prefer less code. — Hugo Sereno Ferreira, Nov 19 '11 at 21:19

missingfaktor · Answer 3 · 2011-11-17T12:08:28.303

Would something like this work for you?

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)
}

That's not optimal, since it can't automatically leverage additional existing numeric conversions... — Jean-Philippe Pellet, Nov 17 '11 at 20:28
@Jean-PhilippePellet: Are you sure it can't? Have a look at implicit generator in `LowerPriorityAdd` trait. It can be easily extended for other numeric operations. — missingfaktor, Nov 17 '11 at 21:17
The problem is not that it *can* be extended: it even *must* be extended. I think my proposed solution doesn't need this extra step. — Jean-Philippe Pellet, Nov 18 '11 at 11:07
Wow, not even a single vote for attempting to answer. OP is quite generous. — missingfaktor, Nov 23 '11 at 21:03

How to specify a generic function that works as if there is a supertype of Int, Double, etc?

3 Answers3

Linked