Jack of all trades software developer, specialising in Web and Mobile development. Have been programming professionally for over 10 years. These days I mainly do Java and Objective-C, but over the years have developed software in C++, Perl, and Javascript. Tom is a DZone MVB and is not an employee of DZone and has posted 10 posts at DZone. You can read more from them at their website. View Full User Profile

"Operator Overloading" in Scala

  • submit to reddit

So, I've been teaching myself Scala recently, and it's a very interesting language.

One of the nice things I like about it, is it's support for creating DSLs, domain specific languages. A domain specific language - or at least my understanding of it - is a language that is written specifically for one problem domain. One example would be SQL, great for querying relational databases, useless for creating first person shooters.

Of course Scala itself is not a DSL, it's a general purpose language. However it does offer several features that allow you to simulate a DSL, in particular operator overloading, and implicit conversions. In this post I'm going to focus on the first of these...

Operator Overloading

So what's operator overloading?

Well operators are typically things such as +, -, and !. You know those things you use to do arithmetic on numbers, or occasionally for manipulating Strings. Well, operator overloading - just like method overloading - allows you to redefine their behaviour for a particular type, and give them meaning for your own custom classes.

Hang on a minute! I'm sure someone once told me operator overloading was evil?

Indeed, this is quite a controversial topic. It's considered far too open for abuse by some, and was so maligned in C++ that the creators of Java deliberately disallowed it (excepting "+" for String concatenation).

I'm of a slightly different opinion, used responsibly it can be very useful. For example lots of different objects support a concept of addition, so why not just use an addition operator?

Lets say you were developing a complex number class, and you want to support addition. Wouldn't it be nicer to write...

Complex result = complex1 + complex2;

...rather than...

Complex result = complex1.add(complex2);

The first example is much more natural don't you think?

So Scala allows you to overload operators then?

Well, not really. In fact, technically not at all.

So all this is just a tease? This is the most stupid blog post I've ever read. Scala's rubbish. I'm going back to Algol 68.

Wait a second, I've not finished. You see Scala doesn't support operator overloading, because it doesn't have operators!

Scala doesn't have operators? You've gone mad, I write stuff like "sum = 2 + 3" all the time, and what about all those funny list operations? "::", and ":/". They look like operators to me!

Well they're not. The thing is, Scala has a rather relaxed attitude to what you can name a method.

When you write...

sum = 2 + 3,

...you're actually calling a method called + on a RichInt type with a value of 2. You could even rewrite it as...

sum = 2.+(3)

...if you really really wanted to.

Aha, I got it. So how do you go about overloading an operator then?

Simple, it's exactly the same as writing a normal method. Here's an example.

class Complex(val real : Double, val imag : Double) {
  def +(that: Complex) =
            new Complex(this.real + that.real, this.imag + that.imag)
  def -(that: Complex) =
            new Complex(this.real - that.real, this.imag - that.imag)
  override def toString = real + " + " + imag + "i"
object Complex {
  def main(args : Array[String]) : Unit = {
       var a = new Complex(4.0,5.0)
       var b = new Complex(2.0,3.0)
       println(a)  // 4.0 + 5.0i
       println(a + b)  // 6.0 + 8.0i
       println(a - b)  // 2.0 + 2.0i

Ok that's nice, what if I wanted a "not" operator though, ie something like a "!"

That's a unary prefix operator, and yes scala can support these, although in a more limited fashion than an infix operator like "+"

Only four operators can be supported in this fashion, +, -, !, and ~. You simply need to call your methods unary_! or unary_~, etc. Here's how you might add a "~" to calculate the magnitude of a Complex number to our complex number class

class Complex(val real : Double, val imag : Double) {
    // ...
    def unary_~ = Math.sqrt(real * real + imag * imag)
object Complex {
  def main(args : Array[String]) : Unit = {
     var b = new Complex(2.0,3.0)
     prinln(~b) //  3.60555

So that's all pretty simple, but please use responsibly. Don't create methods called "+" unless your class really does something that could be interpreted as addition. And never ever redefine the binary shift left operator "<<" as some sort of substitute for println. It's not clever and you'll make the Scala gods angry.

Hope you found that useful. Next up I'll cover implicit conversions. Another nice feature of Scala that really allows you to write your code in a more natural way



Published at DZone with permission of Tom Jefferys, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)


Erik Post replied on Fri, 2012/04/27 - 6:43am

Hi Tom,

Cool article! If I could make a few small suggestions... Consider turning your Complex class into a case class:
case class Complex(re: Double, im: Double)

 That way, you get an Algebraic Data Type with nice syntax support for builders (you can drop the 'new' operator) and pattern matching. Generally you'll want to use (immutable) vals instead of vars unless you absolutely need mutability:
val a = Complex(4.0, 5.0)

 Btw, you can write the signature of your Unit methods such as your main method like this, omitting the': Unit =' bit:
def main (args: Array[String]) { 

Alternatively, just say  
object Complex extends App {   
  // code goes here, no need for a main function

Erwin Mueller replied on Mon, 2012/04/30 - 12:42am

I really like to see for once an example for OpOv that does not include anything math related. Because Op. like +-*/ are really make only sense in a math context and nothing else.

Also a language like Groovy is solving the issue way better, by omitting the parenthesis (of course you can also use OpOv in Groovy):

result = complexA add complexB


Erik Post replied on Mon, 2012/04/30 - 3:38pm in response to: Erwin Mueller

What issue do you mean exactly that Groovy 'solves better'? Scala doesn't require parentheses either, as the article points out.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.