Recursively using implicit methods in Scala

Question

I'd like to define some implicit methods for arrays of doubles to make my code cleaner. Ideally, they would look like this:

type Vec = Array[Double]

implicit def enrichVec(v: Vec) = new {
  def /(x: Double) = v map (_/x)
  def *(u: Vec) = (v zip u) map {case (x,y) => x*y} sum
  def normalize = v / math.sqrt(v * v)
}

However the normalize function doesn't work as written because Scala won't apply implicit methods recursively. Specifically, I get an error Note: implicit method enrichVec is not applicable here because it comes after the application point and it lacks an explicit result type. I could avoid this by explicitly writing out the code for normalize, but that would be ugly. Is there a nicer solution?

Neil Essy · Accepted Answer · 2011-11-30T05:10:40.370

6

The anonymous class inhibits the recursive function definitions. You need to define the "RichVec" as a class and then separately define the implicit conversion.

type Vec = Array[Double]
implicit def enrichVec(v: Vec) = RichVec( v )
case class RichVec( v: Vec ) {
  def /(x: Double) = v map (_/x)
  def *(u: Vec) = (v zip u) map {case (x,y) => x*y} sum
  def normalize = v / math.sqrt( v * v )
}

edited Nov 30 '11 at 05:10

answered Nov 30 '11 at 03:54

Neil Essy

3,607
1
19
23

This doesn't compile (am trying with Scala 2.9.0-1): `error: value / is not a member of Vec` – Luigi Plinge Nov 30 '11 at 04:28
Ironically the v / math.sqrt( v * v ) works if you move the implicit above the case class – Neil Essy Nov 30 '11 at 05:07
Any particular reason you used `case class` here instead of just `class`? – davidsd Nov 30 '11 at 06:07
RichVec( v ) == RichVec( v ) holds true for case classes. However it is not a complete RichVec and equals would have to be redefined anyway making the use of case class useless for that purpose. – Neil Essy Nov 30 '11 at 06:25
To sum up that last comment. No, not based on a complete thought anyway. – Neil Essy Nov 30 '11 at 06:27

score 0 · Answer 2 · answered Nov 30 '11 at 16:12

This works:

type Vec = Array[Double]
abstract class RichVec(v: Vec) {
  def /(x: Double): Vec
  def *(u: Vec): Double
  def normalize: Vec
}
implicit def enrichVec(v: Vec): RichVec = new RichVec( v ) {
  def /(x: Double) = v map (_/x)
  def *(u: Vec) = (v zip u) map {case (x,y) => x*y} sum
  def normalize = v / math.sqrt(v * v)
}

But there are other ways to do it. What is most important is that you specify the return type for the implicit.

Recursively using implicit methods in Scala

2 Answers2