Scala - implicit conversion of Int to Numeric[Int]

Question

I've created a class that can be parameterised by anything that can be converted to Numeric

class Complex[T <% Numeric[T]] (val real : T, val imag : T) {
   //... complex number methods ...
}

Then elsewhere in the code I try:

var myComplex = new Complex(0, 1)

This raises a compilation error because (surprisingly) there's no implicit conversion between Int and Numeric[Int] or even between Int and Integral[Int].

Am I missing something? Is there an implicit conversion somewhere I'm not seeing?

There's an implicit object called IntIsIntegral defined in Numeric.scala. I've tried using this to create my own implicit conversion method:

def implicit intToNumericInt(val i : Int)(implicit n : IntIsIntegral) = n.fromInt(i)

I'm surprised that this is required and, anyway, it seems to lead to an infinite recursion into the .fromInt method.

I'm sure that I'm missing something basic (as you can tell, I'm new to Scala) so would appreciate a point in the right direction.

As you can see from the example, I'm trying to get a Complex number implementation working which can accept and work with any Numeric type. I hope to contribute this to the scalala (linear algebra) project. Following that, I want to introduce a Trait which describes the responsibilities of elements in a matrix (mainly just + and * operators) and retrofit support for complex numbers into the matrix manipulation library.

Answer 1

You are using it wrong. The correct usage is like this:

class Complex[T](val real : T, val imag : T)(implicit num: Numeric[T]) {
   import num._ // make implicit conversions available
   //... complex number methods ...
}

It is the same difference as in between Ordered and Ordering. An Ordered[T] instance can be compared to T, while an Ordering[T] provides a method that compares a a couple of T.

Answer 2

In Scala 2.8, it can also be written as

class Complex[T: Numeric] (val real : T, val imag : T) {

  def +(that: Complex[T]) = {
    val r = implicitly[Numeric[T]].plus(this.real, that.real)
    val i = implicitly[Numeric[T]].plus(this.imag, that.imag)
    new Complex(r, i)
  }

}

This syntax is admittedly a bit dense, but it can be made more readable like this:

class Complex[T: Numeric] (val real : T, val imag : T) {
  val num = implicitly[Numeric[T]]

  def +(that: Complex[T]) = {
    new Complex(num.plus(this.real, that.real), num.plus(this.imag, that.imag))
  }

}

The declaration class C[T: M]( ... ) { val x = implicitly[M[T]] would seem to be equivalent to class C[T]( ... )(implicit x: M[T]) { import x._ as noted in the comments to the previous solution. It's not simply syntactic sugar, because there are differences in how it is compiled, e.g. in the first case x is a method, and in the second case it's a field.