Prabhu Sunderaraman

Operators like +, – , * and so on are actually not operators in traditional sense in Scala language. They all are methods. :). Scala language provides a relaxed syntax when it comes to method invocations. The dot (.) and braces between the objects and method names are optional. When you say object1 + object2 it actually is translated into object1.+(object2).

Therefore operator overloading in Scala means implementing a method with the operator as the name of the method. Let’s learn this with an example. We’ll create a class called Shape with height and width variables. We’ll implement the + and * methods as shown below.

class Shape(private val theHeight:Int,private val theWidth:Int){
  val height = theHeight;
  val width = theWidth;
  def +(another:Shape):Shape = {
     new Shape(this.height+another.height,this.width+another.width)
  }
  def *(another:Shape):Shape = {
	new Shape(this.height*another.height,this.width*another.width)	  
  }
}

You can invoke the + and * methods on Shape objects as shown below.

var shape1 = new Shape(10,20)
var shape2 = new Shape(30,20)
var shape3 = shape1 + shape2
println(shape3.height + ", " + shape3.width)//Prints 40,40

var shape4 = shape1 * shape2
println(shape4.height + ", " + shape4.width)//Prints 300,400

You can invoke + and * methods together. You don’t have operator precedence in Scala however. Instead Scala has method priorities. If you invoke multiple methods in a single statement the asterik, slash characters are given high priority followed by the plus, minus and so on. The methods with letters have the least priority. So if you have a method call like this obj1 + obj2 * obj3 foo(obj4). The asterik method is invoked first, followed by plus and finally the foo method is called.

 var s1 = new Shape(10,20)
 var s2 = new Shape(30,40)
 var s3 = new Shape(50,60)
 var s4 = s1 + s2 * s3 
 println(s4.height + ", " + s4.width) //Prints 1510,2420

Continuing with the posts on Scala where we implemented Guessing game in imperative style and a in a couple of ways using the functional style, let’s implement it using pattern matching facility.

Pattern matching provided in Scala is one of the most widely used features. It’s a glorified form of switch-case statements, though comparing it with a switch-case construct would mean belittling it. Given below is the guessing game implemented using pattern matching feature in Scala.

object GuessingGamePattern {
  val target:Int = (Math.random*100).asInstanceOf[Int]
  
  def play(guess:Int):Boolean = {
    guess match {
      case num:Int if (num > target) => println("Aim Lower");false
      case num:Int if (num < target) => println("Aim Higher");false
      case num:Int if (num == target)=> println("You've got it!!!");true
    }
  }
  
  def main(args:Array[String]):Unit = {
    println("Enter a number between 1 and 100")
    var gameOver = false
    var guess:Int = -1
    var attempts:Int = 0
    while(!gameOver){
		  guess = readLine().toInt
		  gameOver = play(guess)
		  attempts += 1
	  }
	  println("Attempts: " + attempts)  
  }
}

If you take a close look at the play method, you’d notice we’ve used pattern matching. You pass the guess value to the play method and try to match it with the condition and return a boolean value.

Now that, we’ve been playing with guessing game in different ways, we’ll take up another example and implement it using Scala

In the earlier post on Scala, we created the Guessing Game class using imperative style. Now you’ve the GuessingGame class implemented using functional style. This is the first attempt in doing that.

Couple of points to keep in mind here is in the functional style the classes are designed to be immutable and the variables are designed to be final using the val keyword. Here’s the code snippet that has the GuessingGame class configured as a functional class.

class GuessingGame(theTarget:Int,theAttempts:Int,theMessage:String,theGameOver:Boolean) {
	val target:Int = theTarget;
	val attempts:Int = theAttempts;
	val message:String = theMessage;
	val gameOver:Boolean = theGameOver;
	def play(guess:Int):GuessingGame = {
	  new GuessingGame(
	      target,
	      attempts+1,
	      if(guess>target) "Aim Lower" else if(guess < target) "Aim Higher" else "You've got it!!!",
	      if(guess == target) true else false
	  )
	}
}
object GuessingGameUser {
	def main(args:Array[String]){
	  var game:GuessingGame = new GuessingGame((Math.random*100).asInstanceOf[Int],0,"",false)
	  println("Enter a number between 1 and 100")
	  var guess:Int = -1
	  while(!game.gameOver){
		  guess = readLine().toInt
		  game = game.play(guess)
		  println(game.message)
	  }
	  println("Attempts: " + game.attempts)
	}
}

Though it’s functional there’s a bit of weight added to the code. In the next post let’s see how we can refactor it and make it lightweight.