Scala: method\operator overloading

Question

The following example is from the book \'Programming in Scala\'. Given a class \'Rational\' and the following method definition:

def add(that: Rational): Rat         


        

Answer 1

If you call + with explicit this, it should work

def +(that: Int): Rational = this.+(new Rational(that, 1))

Scala allows to define unary operators that can be used in prefix operator notation. For example you can use + as a prefix operator to achieve the same:

def unary_+: Rational = this.+(new Rational(that, 1))
val a = new Rational(3,2)
val b = +a

Without explicit this in your example, the compiler thinks that you are using unary operator + which is not defined.

Answer 2

In Scala, any construct of the type +x, -x, ~x and !x is transformed into a method call x.unary_+, etc. This is partially to allow Java-like syntax of having !b as the negation of the boolean b, or -x as the negation of the number x.

Therefore, the code snippet +(new Rational(that, 1)) is translated into (new Rational(that,1)).unary_+, and as Rational doesn't have this method, you get a compile error. You will get this error only if your function is called +, -, ~ or ! as these are the only characters Scala allows as unary operators. For example, if you called your function @+, the code compiles just fine.

Though, I would suggest writing the overridden add function as:

def +(that: Int): Rational =
  this + (new Rational(that, 1))

This code shows the intent of your function better -- you add a new Rational constructed from an integer as a numerator and 1 as denominator to this. This way of writing gets translated into this.+(new Rational(that, 1)), which is what you want -- invoking the + function on this.

Note that you can use the infix notation however the function is called. For example, if you change the name back to add, you can still keep the definition as:

def add(that: Int): Rational =
  this add (new Rational(that, 1))

Answer 3

You haven't specified the binary + operator, you've specified the unary + operator.

So instead of:

def +(that: Int): Rational =
  +(new Rational(that, 1))

You need to write this:

def +(that: Int): Rational =
  this +(new Rational(that, 1))