In this post I would like to cover:

• What are case classes?
• What is Option class and its application?
• What is Either class and its application?

What are case classes?

From the Official Scala Doc:

Scala supports the notion of case classes. Case classes are regular classes which export their constructor parameters and which provide a recursive decomposition mechanism via pattern matching.

Examples of the case classes include scala.Some, scala.util.Left, scala.util.Right. And the application of case classes can be read in the below topics.

What is Option class?

From the Scala API, Option class:

Represents optional values. Instances of Option are either an instance of scala.Some or the object None.

Prior to Java 8, there is no support for creating objects which either hold some value or dont hold any value. This support has been provided by external APIs like Guava and others. In Java 8 there is a new class added called Optional ( I would write about this sometime in future).

There are 2 variants of Option namely Some and None. The former represents presence of a value and stores the value within it and the latter represents the absence of value. Lets have a look at an example:

//Uses of Option class
object OptionDemo {
  def main(args: Array[String]) {   
    val result1 = loadData(true)
    val result2 = loadData(false)
    println(result1.getClass())//Prints class scala.Some
    println(result2.getClass())//Prints class scala.None$

    //getOrElse- either returns the value present or 
    //returns the value after evaluating the parameter.
    println(result1.getOrElse("Error!"))
    println(result2.getOrElse("Error!"))
    
  }

  def loadData(condition: Boolean): Option[String] =
    if (condition) {
      Some("Data found!")
    } else {
      None
    }

}

In the above simple example an instance of Some or singleton None is returned by the loadData based on some condition and then make use of the return values to print out the their types as well as their contents using the getOrElse method. Lets see another way to make use of the return values from the loadData method. In the below example we make use of the advanced pattern matching mechanism to extract the contents of the object. This is possible because the classes Some and None are case classes.

object OptionDemo {
  def main(args: Array[String]) {   
    val result1 = loadData(true)
    val result2 = loadData(false)
    
    //Prints: found details:Data for employee 1234
    matcher(result1)
    //Prints: No data found
    matcher(result2)
  }
  
  //Using pattern matching to decompose the parameter.
  def matcher(result: Option[String]){
    result match{
      case Some(msg) => println("found details:" + msg)
      case None      => println("No data found")
    }
  }

  def loadData(condition: Boolean): Option[String] =
    if (condition) {
      Some("Data for employee 1234")
    } else {
      None
    }

}

What is Either class?

From the Scala API, Either class:

Represents a value of one of two possible types (a disjoint union.) Instances of Either are either an instance of scala.util.Left or scala.util.Right.

And just after the it states the use of Either class:

A common use of Either is as an alternative to scala.Option for dealing with possible missing values. In this usage, scala.None is replaced with a scala.util.Left which can contain useful information. scala.util.Right takes the place of scala.Some. Convention dictates that Left is used for failure and Right is used for success.

In the below example we make use of Left class to populate the data is some operation is successful and make use of Right class to populate the exception message in case of failure. The success condition is when the passed number is even and the failure condition is when the passed number is odd.

object EitherDemo {
  def main(args: Array[String]) {
    val div1 = even(12)
    val div2 = even(11)
    matcher(div1)//Prints 12.0
    matcher(div2)//Prints "The number 11.0 is not even"
    
  }
  
  def matcher(matchElement:Either[String, Double]){
    matchElement match {
      case Left(msg) => println(msg)
      case Right(rem) => println(rem)
    }
  }

  def even(number:Double): Either[String, Double] =
    if (number % 2 == 0) {
      Right(number)
    } else {
      Left("The number "+ number +" is not even");
    }

}

In the above example Left and Right case classes have been used in pattern matching in the same way the classes Some and None were used in the first example.

This was in very brief about Option and Either classes in Scala and how case classes can be used for pattern matching.

I have divided the post into different sections namely:

1. Simple example of object
2. An example of inbuilt object in Scala library
3. Companion classes and Companion objects
4. Companion object with apply method

object SimpleObject{
  val param1 : Int = 10
  var param2 : String = "Yes"
    
  def method1 = "Method 1"
  
  def sum(a:Int, b:Int) = a + b
}
object Main {
  
  def main(args: Array[String]) = {
    
    println(SimpleObject.param1)
    
    println(SimpleObject.param2)
    
    SimpleObject.param2 = "No"
      
    println(SimpleObject.param2)
    
    println(SimpleObject.method1)
    
    println(SimpleObject.sum(10, 15));
      
  }

}

In the above object- SimpleObject we have declared 2 parameters and 2 methods. To know the different between var and val please read val versus var in scala. The SimpleObject object is used in another object Main which declares the main method. The Main object containing the main is the starting point of the application. People from the Java world will immediately relate the use of the SimpleObject to the static members in Java. I will touch upon that concept as well towards the end of the post when I explain about Companion classes.

An important feature of an object in Scala is that it is Singleton i.e there is only one instance. And you cannot even use the new operator to create another instance.

An example of inbuilt object in Scala library

There are numerous examples of object‘s in Scala API and one among them is the Console object which

Implements functionality for printing Scala values on the terminal as well as reading specific values. Also defines constants for marking up text on ANSI terminals.

Lets look at an example of using Console object:

object Main {
  
  def main(args: Array[String]) = {
    Console.println("Enter some string: ");
    
    val input = Console.readLine;
    
    Console.println("The string entered is: "+input)
 
  }

}

Companion classes and Companion objects

By now you have an brief idea of what an object is. Now lets see yet another concept associated with object called the Companion classes/Companion objects. When we have an object with same name as that of the class then we say that the object is a Companion object and the class is companion class. In addition to having the same name, they should be part of the same package and be defined in the same file.

The below code shows the Companion objects in action:

object Main {
  
  def main(args: Array[String]) = {
    
    var emp = new Employee(123,"Sana", "Blore")
    println(emp)//123 Sana, Blore
    Employee.saveToDb(emp)//Saving: Sana to db
  }

}

//Companion class
class Employee(id:Int, n:String, p: String){
  val empId = id
  val name = n
  val place = p
  
  override def toString() = 
    this.empId+" "+this.name+", "+this.place
}

//Companion object
object Employee{
  def saveToDb(emp: Employee){
    println("Saving: " + emp.name+" to db");
  }
}

In the above code we have an Employee class and an associated companion object. The companion object defines a method called saveToDb. In the same code I have shown how the companion class and companion object are used. The method saveToDb exhibits behaviour similar to that of the statics in Java. In scala there is no concept of “static” members, the same functionality is provided by the companion object.

Looking at the same example in Java we would have:

public class StaticSample {
  
  public static void main(String[] args){
    Employee emp = new Employee(123, "Sana", "Blore");
    System.out.println(emp);//123 Sana, Blore
    
    //Accessing the static method using the object.
    emp.saveToDb(emp);//Saving employee: Sana
    
    //Accessing the static method using class name.
    Employee.saveToDb(emp);//Saving employee: Sana
  }

}

class Employee{
  String name;
  String place;
  int id;
  public Employee(int id, String name, String place) {
   this.id = id;
   this.name = name;
   this.place = place;
  }
  public String toString(){
    return this.id+" "+this.name+", "+this.place;
  }
  public static void saveToDb(Employee emp){
    System.out.println("Saving employee: "+emp.name);
  }
}

One can notice that in Java the static members can be accessed both using the instance and the class name, which can be quite confusing. But the same is not possible in Scala because the only way to access the members in the companion object is to use the companion object and not the instance of the companion class.

Companion class/object in Scala API

In Scala API there are numerous places where concept of companion object is leverage and one such usage is the Array class. The companion object for Array class consists of methods like apply, copy, empty among others.

Companion object with apply method

Lets consider the Employee example from above and add an apply method to it. The use of apply method is that it provides a way to create instances of the companion class without using the new operator directly and instead use the object literal syntax to create the instance of the companion class. Lets look at the sample code:

//replace this with the use of new operator above.
var emp = Employee(123,"Sana", "Blore")

object Employee{
  //Rest of the definition is as above.
  def apply(id: Int, name: String, place: String) =
    new Employee(id, name, place)
}

The apply method can be used to create Factories for creating instances of the companion class.

In the Scala API Array class contains apply method which enables us to create arrays like:

var arr1 = Array(1,2,3,4,5)
var arr2 = Array("a","b","c")    

This was in brief about object in Scala.

Some of the recommended books for learning Scala:

• Scala for the Impatient
• Programming in Scala

Some of the not so good things:

• You dont get to see lot of idomatic scala code. Unlike Core Java where the examples gave the reader an idea of how to organise code. It is acceptable considering the size of the book.
• The questions dont have solutions so its difficult to evaluate if your code follows best practices.

This would not be the last book you would read, I am sure once you finish this book you would be in a better position to read other Scala books and try to grasp the advanced scala concepts and also learn to write idomatic scala code.

The ideal approach to read this book is to practice the exercises and also keep the Scala API documentation handy.

Being a newbie with lot of failed efforts to learn Scala, I found this book to be easy to pick scala concepts and also familiarize with the code.

This review was originally posted at: Javaranch Book Review and I received a copy of the book for the reveiw.

[scala gutter=”false”]
(x:Int,y:Int) => x+y
[/scala]

Function value- When this function literal is assigned to a reference they become function values. The are similar to the Objects created from the class. These are created at runtime

[scala gutter=”false”]
var sum = (x:Int,y:Int) => x+y
[/scala]

So in the above case we can use sum to invoke the method.

[scala gutter=”false”]
println(sum(5,7))
[/scala]

So coming to the partially applied functions- We always pass all the arguments while invoking the method. But in Scala we can pass some of the arguments defined in the function there by creating a partially applied function. So the rest of the arguments can be passed when the function is being invoked. Lets have a look at an example before going into detail of how its implemented.

[scala]
object PartialFunction extends Application
{
def sum(a:Int,b:Int,c:Int) = a+b+c
val partial1 = sum _
val partial2 = sum(1,_:Int,8)
println("Partial 1: "+partial1(5,6,7))
println("Partial 2: "+partial2(4))
}
[/scala]

The output would be:

[bash gutter=”false”]
C:devscalapartial>fsc PartialFunction.scala

C:devscalapartial>scala PartialFunction
Partial 1: 18
Partial 2: 13
[/bash]

Lets pay attention to the line-4 and line-5 above. With

[scala gutter=”false”]val partial1 = sum _ [/scala]

we say that the arguments would be supplied later on, when its invoked using partial1. With

[scala gutter=”false”]val partial2 = sum(1,_:Int,8)[/scala]

we are providing 2 arguments now and the third one would be provided when invoked using partial2. In each of the above 2 line- A function value object is created which is of type- Function3 (for partial1) and Function1(for partial2). FunctionN is a trait with an apply method with N parameters. So Function1 means- an apply method with 1 parameter and so on. Now that we have the function values- we invoke them by passing required arguments.

Lets look what methods does the class file generate-

[scala]
C:devscalapartial>javap PartialFunction
Compiled from "PartialFunction.scala"
public final class PartialFunction extends java.lang.Object{
public static final void main(java.lang.String[]);
public static final void scala$Application$_setter_$executionStart_$eq(long);
public static final long executionStart();
public static final scala.Function1 partial2();
public static final scala.Function3 partial1();
public static final int sum(int, int, int);
}
[/scala]

So we can see 2 methods there- partial2() and partial1(). We might be surprised to see that they arent taking any arguments. But in our example above we have passed arguments to these function values. So there’s something wrong?? No, there’s nothing wrong. If we look at the return type for partial1 and partial2 its Function3 and Function1 respectively. And when you compile the scala code shown in the beginning, you get 2 more class files generated:

[bash]
C:devscalapartial>ls
PartialFunction$$anonfun$1.class
PartialFunction$$anonfun$2.class
[/bash]

And when inspected these classes, the following could be seen

[scala]
C:devscalapartial>javap PartialFunction$$anonfun$1
Compiled from "PartialFunction.scala"
public final class PartialFunction$$anonfun$1 extends scala.runtime.AbstractFunction1$mcII$sp implements java.io.Serializable{
public static final long serialVersionUID;
public static {};
public final int apply(int);
public int apply$mcII$sp(int);
public final java.lang.Object apply(java.lang.Object);
public PartialFunction$$anonfun$1();
}

[/scala]

You can see that class extends scala.runtime.AbstractFunction1(this actually extends Function1). So PartialFunction$$anonfun$1 IS-A Function1. You can also see an apply method with one argument- the missing argument in the function value. So we are actually invoking this apply method. Same goes with the other class as well:

[scala]
C:devscalapartial>javap PartialFunction$$anonfun$2
Compiled from "PartialFunction.scala"
public final class PartialFunction$$anonfun$2 extends scala.runtime.AbstractFunction3 implements java.io.Serializable{
public static final long serialVersionUID;
public static {};
public final int apply(int, int, int);
public final java.lang.Object apply(java.lang.Object, java.lang.Object, java.lang.Object);
public PartialFunction$$anonfun$2();
}
[/scala]

Note that the above apply() takes three arguments/complete argument list.This indicates that the function(partial1) doesnt not take any arguments when creating a function value of sum function.

I had asked a query on Stackoverflow regarding the advantages of using Partially Applied functions. So this is what I could get from the replies there:

Although you can’t assign a method or nested function to a variable, or pass it as an argument to another function, you can do these things if you wrap the method or nested function in a function value by placing an underscore after its name.

So lets add some checks for the parameters being passed- Lets say we dont want the firstName to be passed as empty string.

[scala]
class Person(firstName: String, lastName: String){
require(firstName!=null && !firstName.equals(""))
override def toString():String = firstName+" " +lastName
}
[/scala]

require method defined in the Predef object is used to check for conditions. So lets try to create an instance of Person and see how this check helps:

[scala]
scala> var p = new Person("","Sanaulla")
java.lang.IllegalArgumentException: requirement failed
at scala.Predef$.require(Predef.scala:133)
at Person.<init>(<console>:6)
at .<init>(<console>:6)
at .<clinit>(<console>)
at RequestResult$.<init>(<console>:9)
at RequestResult$.<clinit>(<console>)
at RequestResult$scala_repl_result(<console>)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at scala.tools.nsc.Interpreter$Request$$anonfun$loadAndRun$1$$anonfun$apply$18.apply(Interpreter.scala:981)
at scala.tools.nsc.Interpreter$Request$$anonfun$loadAndRun$1$$anonfun$apply$18.apply(Interpre…
scala> var p = new Person("Mohamed","Sanaulla")
p: Person = Mohamed Sanaulla
[/scala]

So if we try to pass an empty string for the firstName- An IllegalArgumentException is thrown.
With the above implementation of constructor, we will not be able to access the values of firstName and lastName from outside the class. So for this, we can add 2 fields for the same:

[scala]
class Person(fName:String, lName:String){
require(firstName!=null && !firstName.equals(""))
var firstName:String = fName //Using fields instead of construcotr params
var lastName: String = lName
override def toString():String = firstName+" "+lastName
}
[/scala]

Now lets see how we can add multiple constructors,. in other words- Auxiliary Constructors. Suppose we wanted to make the lastName as optional, in that case we can provide an auxiliary constructor which would just take one parameter- firstName. Auxiliary constructors being with: def this(<Parameter List>).

[scala]
class Person(fName: String, lName:String){
require(firstName!=null && !firstName.equals(""))
var firstName = fName
var lastName = lName
def this(fName:String) = this(fName,"")//Auxiliary constructor
override def toString():String = firstName+" "+lastName
}
[/scala]

We would have to note here that the first statement of auxiliary constructor must be a call to the another constructor of the same class and it should be declared before the calling constructor. In Java- the first statement would be- a call to this or super constructor, In Scala, super constructor can only be called from the primary constructor. If we analyse the methods generated in the class file of Person, we can see that there’s is an Overloaded constructor-

[scala]
C:devscalablogPost>javap Person
Compiled from "OOP1.scala"
public class Person extends java.lang.Object implements scala.ScalaObject{
public java.lang.String firstName();
public void firstName_$eq(java.lang.String);
public java.lang.String lastName();
public void lastName_$eq(java.lang.String);
public Person(java.lang.String);
public java.lang.String toString();
public Person(java.lang.String, java.lang.String);
}
[/scala]

• Classes
• Objects
• Constructors
• Overloaded Constructors

Classes:
Like in Java, classes in Scala are also declared using the key word- class.

[scala]
class Person{
}
[/scala]

Lets give some fields and methods for this class. So the fields can be declared as either- var’s and val’s (Read about their difference here). And the methods are declared using the keyword- def. Java programmers might note this difference in method declaration. The method names can be same as long as their full signatures(type name, list of parameters with types and the return) must be unique- what we would call as Overloading. So the enhanced version of the class:

[scala]
class Person{
var firstName = "Mohamed"
var lastName = "Sanaulla"
override def toString:String= firstName+" "+lastName
}
[/scala]

So I have added 2 fields- firstName and lastName. In Scala- if no access level is specified, then its public. So lets try to create an instance of this Person.

[scala]
scala> var person2 = new Person
person2: Person = Mohamed Sanaulla

scala> person2.firstName
res2: java.lang.String = Mohamed

scala> person2.lastName
res3: java.lang.String = Sanaulla

scala> person2.firstName = "FirstName"

scala> person2.lastName = "LastName"

scala> println(person2.firstName)
FirstName

scala> println(person2.lastName)
LastName
[/scala]

So we can see that we use the same- “new” operator to create an instance. As we don’t have a constructor we are not passing any values while creating the instance. Also we are able to get and set the values of the fields. And the methods in a scala Class are declared with the key word def. In the above code you can also see another keyword being used: override– This is to indicate that its an overridden version of toString().

Coming to another important difference in Scala- classes cannot have static members. Those members supposed to be static are added in a special construct called “Singleton Object“- which means- Only One Object of that type. We cannot use new for Singleton Objects. Lets take a look at an example:

[scala]
object MySingletonObject{
var count=100
def getCount = count
}
[/scala]

So how do we use this?

[scala]
scala> MySingletonObject.getCount
res0: Int = 100
[/scala]

See we havent used the new to create an instance of a Singleton Object.
Lets peek at the class file generated for Person-

[bash]
C:devscalablogPost>javap Person
public class Person extends java.lang.Object implements scala.ScalaObject{
public java.lang.String firstName();
public void firstName_$eq(java.lang.String);
public java.lang.String lastName();
public void lastName_$eq(java.lang.String);
public java.lang.String toString();
public Person();
}
[/bash]

So you can see there’s a geter, a setter having the name same as that of the name of the field. Scala doesnt use JavaBeans naming convention for the getters and setters. Looking at the class file for the Singleton Object:

[bash]
C:devscalablogPost>javap MySingletonObject
Compiled from "OOP1.scala"
public final class MySingletonObject extends java.lang.Object{
public static final int getCount();
public static final void count_$eq(int);
public static final int count();
}
[/bash]

You can see that internally it has generated static members. And for var fields- there’s a setter method generated as: _$eq and this allows the programmer to set the values for the var field (which is public).

In the Person class- the fields are public. Lets have a look at how we can use Constructors and increase the level of hiding for the fields.
Unlike Java, constructors in Scala are bit different. In Scala you have two types of constructors- primary and auxiliary constructors. The primary constructors comprise the complete class declaration. Lets have a look at how we can modify the Person class to support constructor.

[scala]
class Person(firstName:String, lastName:String){
override def toString():String = firstName+" "+lastName
}
[/scala]

In the above example we have primary constructor taking 2 String parameters. Lets look at the class file generated before explaining further:

[bash]
C:devscalablogPost>javap Person
Compiled from "OOP1.scala"
public class Person extends java.lang.Object implements scala.ScalaObject{
public java.lang.String toString();
public Person(java.lang.String, java.lang.String);
}
[/bash]

So you can see that there’s no methods generated for setting or getting these parameter fields. This is because by default the parameters in the constructors are declared as private val. How do we create an instance of Person then?

[scala]
scala> var p = new Person("Mohamed", "Sanaulla")
p: Person = Mohamed Sanaulla

scala> println(p)
Mohamed Sanaulla
[/scala]

So its pretty similar to the way we create an instance in Java. Lets play with the parameters of the constructor a bit further-

[scala]
class Person(var firstName:String, var lastName:String){
override def toString():String = firstName+" "+lastName
}
[/scala]

The class file generated for this would be:

[scala]
C:devscalablogPost>javap Person
Compiled from "OOP1.scala"
public class Person extends java.lang.Object implements scala.ScalaObject{
public java.lang.String firstName();
public void firstName_$eq(java.lang.String);
public java.lang.String lastName();
public void lastName_$eq(java.lang.String);
public java.lang.String toString();
public Person(java.lang.String, java.lang.String);
}
[/scala]

So you see with constructor parameters becoming var, the compiler automatically generates the methods to access and set these values. We can make them private and var- by preceding the var keyword in the parameter list by: private. And then we can add methods to get the values for these parameters. So these parameters of the primary constructor are accessible within the class declaration(provided they are not public).

More about constructors is continued here.

Nil– Represents an emptry List of anything of zero length. Its not that it refers to nothing but it refers to List which has no contents.

Nothing is a Trait. Its a subtype of everything. But not superclass of anything. There are no instances of Nothing.

None– Used to represent a sensible return value. Just to avoid null pointer exception. Option has exactly 2 subclasses- Some and None. None signifies no result from the method.

Unit– Type of method that doesn’t return a value of anys sort.

Note: Any is supertype of AnyRef and AnyVal. AnyRef is the supertype of all the reference classes (like String, List, Iterable) in scala. AnyVal is the supertype of all the value classes (like Int, Float, Double, Byte, Short..). Null is a subtype of all the reference classes. null is its only instance. Nothing is subtype of every other type i.e of reference and value classes.

Think- AnyRef == Object in Java.

The above is a breif summary of a wonderful post by Matt Malone where he has explained all these concepts in depth with examples. Read the blog post here.

Defining Traits:

A trait definition looks like a class definition but uses the keyword “trait.

trait Bounceable{

     def bounce():String="Bounce Method in Trait"

}

The above declared trait has a concrete method. The ability to declare concrete methods in an trait gives default implementation option. In interfaces one has to write/copy-paste the default declaration in each class which implements the interface or declare a class that implements that interface and let other classes extend the concrete class. The first method has code repition and the second method has the restriction that a class can extend only one class. So this feature of “trait” stands out best.

As in Java a class implements interface, in Scala classes traits are mixed into a class. This is done using either extends or “with” keywords.

class Ball(s: Int) extends Bouncable{

      var size:Int

      override def toString():String= Integer.toString(size)

}

In the above example we are using extends to mix in the trait- Here Ball is implicitly inherits trait’s superclass which is “AnyRef”. Lets try to use the class Ball to test the mixed in trait.

object Test{

           def main(args:Array[String])={

                    var ball = new Ball(33)

                    var ball2:Bounceable= new Ball(400)

                    println(ball.bounce()) //This prints "Bounce Method in Trait"

                    println(ball) //This prints "33"

                    println(ball2.bounce())

                    println(ball2)

         }

}

Note: Output written as comment.

Regarding the ball2 instance being declared as type “Bounceable”. Its a valid declaration cause supertype references can refer to the instances of its subtypes. But they cannot access the methods/fields declared by the subtypes (different with the overriding case).

Lets consider a more better example which extends a class and mix in multiple traits.

Modifying the Ball class a bit:

class Ball(s:Int){

      var size:Int=s;

      override def toString():String="Size of Ball: "+Integer.toString(size)

}

class Basketball(s:Int) extends Ball(s) with Bounceable{

      override def bounce():String="Basketball is bouncing"

      override def toString():String=" Basketball of size: "+size

}

object Test{

      def main(args:Array[String])={ 

            var basketBall= new BasketBall(400)

            println(basketBall)

            println(basketBall.bounce)

      }

}

In the above example class Ball is a super class which the class Basketball is extending and the class Basketball mixes in with Bounceable. The concrete method in Bouncebale is overridden in Basketball. Though the trait may look like Java Interface there are subtle differences. Traits can maintain state by declaring fields. Traits look more or like class with a few exceptions. The traits cannot have class parameters i.e parameters passed to the primary contructors of a class. For example-

• we can have class Ball(x:Int) but not trait Ball(x:Int)
• super call is bound statically but in traits its bound dynamically. This can be used to create a stackable trait.

Let me tell u about Rich and Thin interfaces before contiuning further-

• Rich Interfaces- Too many methods => Easy for client but difficult for implementer
• Thin interfaces- Few mehtods =>Easy for implementer but difficult for client as he has to write more code to get the desired output.

Traits can be used to create Rich Interfaces which are Thin, means traits can have lot of methods- Many of them are implemented in terms of the few unimplemented methods. So the class which mixes these traits provides the implementation for the few unimplemented methods. The end result being whole set of methods making it easy for the implementer and the client as well.

Lets look at one such trait “Ordered”. Suppose u want to create a custom data value and want to provide comparision operators, we would be busy writing methods like lessThan(<), greaterThan(>), lessThanEqualto(<=) and so on. Instead scala provides “Ordered” trait. Extending this trait makes the work lot easier.

In the example below i have created a custom MyRectangle class and extended the trait Ordered. I would be comparing the rectangles based on the “area” of the rectangle. Greater the area, larger is the rectangle.

class MyRectangle(w:Int, h:Int) extends Ordered[MyRectangle]{

      val width:Int=w

      val height:Int=h

      override compare(that:MyRectangle):Int=

            (this.width*this.height)-(that.width*that.height)

}

object MyRectangleTest{

      def main(args:Array[String])={

            val myRect1 = new MyRectanlge(3,4)

            val myRect2 = new MyRectanlge(4,5)

            val res= if(myRect1 > myRect2){ myRect1 } else { myRect2 }

            println(res)

      }

}

One should carefully observe the compare() method. If the difference is positive then the receiver is greater than the argument else the argument is greater. Also note that the type of the objects being compared is passed as the type parameter along with the trait name. Here we have found the difference between the areas of the rectangle. The Ordered trait does not provide the equals method.

There’s one more usage of traits called Stackable traits. I would be writing about it in another post.

• In Scala its not required to use semicolons to terminate a statement if the termination is obvious by line ending. If there are more than one statements on the single line then they have to be separated by using semicolon.

• Scala doesnot require the file containing a class definition to mirror the name of the class.

• In Scala there’s no use of static all together. This is replaced by use of singleton object. Singleton objects are declared by using the keyword “object” and not “class”.

• In Scala, arrays are instances of Array class and uses square brackets ([]) instead of angle brackets (<>) to indicate parameterized types.

• In Scala the variable declaration is: “name: type”

• Scala uses keyword “Unit” to represent functions which return “non-value” value.

• In Scala the syntax for method declaration is different. It uses the “=” before the method body preceeded by the identifier/name of the method along with the parameter list and return type. Functions are treated like variables and constants.

• Scala supports the use of closures, Annonymous functions- Which makes longer code simpler and shorter.

These were few things i have noted. There are lot more differences. If u know any please add it as a comment. Will upadate my post accordingly.

Lets consider a first entry example of If statments, without using much of Scala’s features.

if(5+6==10){

println("You are wrong in calculations")

}else{

println("Keep it up")

}

This is a pretty simple and straight forward examples. Now lets add some Scala flavor in the If-Statement. In Scala If-Statements are expressions, which means that the value from If-Statements can be assigned to some variable. Lets consider another example- Finding greatest of two numbers.

Note: I am using the scala interpreter.

scala>var num1=54
num1:Int=54
scala>var num2=76
num2:Int=76

I have created 2 variables. We will have to write a If-Statement for finding out the greatest value and assign it to another variable.

scala>var big=if(num1>num2){ num1}else{num2}
big:Int=76
scala>println(big)

One can see how the result from a if-expression is assigned to a variable. This feature of If construct has removed the need of a Select case construct. Also note that the Type Inference coming into play there- I haven’t mentioned tat big is a Int but it has inferred based on the If-Statement that it will hold an Int. If we had missed the else part then it would have inferred the type to be Unit (void in Java).

For Loops–

In the Scala world they are also referred to as the “For Comprehension” or “For Expression”. Let’s consider a example list.

scala> var cities=List(“Bangalore,India”, “Delhi, India”, “Chennai, India”,”Tokyo, Japan”, “New York, USA”, “London, UK”, “Paris, France”)

The above code will create a List of Cities along with their countries.  Now lets use a for loop to “comprehend” the list.

scala> for(city <- cities)println(city)

Straight forward and simple. The left arrow operator (<-) is called as "generator” as it is used to generate elements from the list. Now lets print the cities in India with the help of the Scala’s features

scala>for(city <- cities if city.contains("India"))println(city)

Bangalore,India

Delhi, India

Chennai, India

The above technique is called "Filtering“. One can add multiple filers (if condition) and the filers have to be seperated by using “;”.  Now suppose we want to store the Indian cities in a separate list, what do we do? Scala does have a solution to that as well. Lets look at the code:

scala> var indianCities=for(city for(city <-indianCities)println(city)

Bangalore,India

Delhi, India

Chennai, India

The type of the yielded list has not been mentioned. Scala infers the type from the Type of the Collection being used to yeild a new List.

While and Do-While Loops:

While loops, as in other languages, execute the code in the block until the condition is true. Do-While is similar to While the only difference being that the loop is executed at least once and checks to see if the condition is true or not.

Example to find sum of first 10 natural numbers

scala> var i=1

scala>var sum=0

scala>while(iprintln(sum)

An example to show do while loop:

scala>sum=0;i=0;

scala>do{ sum +=i;i+=1}while(sumprintln(i)

That was a brief overview of If, For, While and Do-While constructs.