This is just a little example class to remind me of the syntax and some of the nifty features in Scala that I tend to forget. I essentially take the example of the `Rational ` class from the excellent book "Programming in Scala" by Odersky et al. and modify it slightly.

Let's start very simple. We call the class "Frac" for fraction instead of Rational and its constructor takes the numerator and denominator of the fraction. The `val` specifier ensures that the class is immutable. We also override the `toString` method to get a nice print out.

class Frac(val num:Int, val den:Int) { override def toString = "%d/%d" format (num,den) }

With this class at hand we can now create a fraction and print it and its components:

val a = new Frac(1,2) println(a) println(a.num)

1/2 1

Now let's add a companion object `Frac` that allows us to omit the `new` keyword when creating a fraction. We also want to ensure that the denominator is greater than zero and Scala provides the handy `require` function to test pre-conditions. Furthermore, We add a `toDouble` variable that contains the floating point value of the fraction. Note that we could also have said `def toDouble = ..` instead of `val toDouble = ...` . It is a trade off between speed and memory consumption. The nice thing about Scala is that the call interface remains the same and the implementation could be changed without any dramas.

class Frac(val num:Int, val den:Int) { require(den > 0) val toDouble = num/den.toDouble override def toString = "%d/%d" format (num,den) } object Frac { def apply(num:Int, den:Int) = new Frac(num,den) } println(Frac(1,2)) println(Frac(1,2).toDouble)

1/2 0.5

So far so good. But one problem with the current implementation is that comparisons such as `Frac(1,2) == Frac(1,2)` return `false`. We need to override the `equals()` method and consequently the method `hashCode` should also be overridden:

class Frac(val num:Int, val den:Int) { ... override def equals(other:Any) = other match { case that:Frac => (this eq that) || (that.num == this.num && this.den == that.den) case _ => false } override def hashCode = 13*(num+13*den) ... }

Apart from testing for equality it would be convenient if fractions could be ordered. The current class implementation does not allow to say `Frac(1,3) < Frac(1,2)`, for instance. But implementing the `compare` method of the `Ordered` trait does the trick.

class Frac(val num:Int, val den:Int) extends Ordered[Frac] { ... def compare(that:Frac):Int = (this.num*that.den) - (that.num*this.den) ... }

Operator overloading is another feature of Scala and useful when applied appropriately. For a fraction class it certainly makes sense. To keep things simple the following code is limited to the multiplication of fractions with fractions and fractions with scalars.

class Frac(val num:Int, val den:Int) { ... def *(that:Frac):Frac = Frac(this.num*that.num, this.den*that.den) def *(c:Int):Frac = Frac(num*c, den) ... }

This enables us to compute `Frac(1,3) * Frac(1,2)` and `Frac(1,3) * 2` but we still cannot calculate `2 * Frac(1,3)` because there is no multiplication method for `Int` that takes a fraction. For that we need an implicit function, preferably defined within the companion object:

object Frac { def apply(num:Int, den:Int) = new Frac(num,den) implicit def int2Frac(num:Int):Frac = Frac(num,1) }

Depending on scope it might be necessary to import the implicit function of the companion object but then things work as expected:

import Frac.int2Frac println(Frac(1,3) * Frac(1,2)) // prints 1/6 println(Frac(1,3) * 2) // prints 2/3 println(2 * Frac(1,3)) // prints 2/3

When multiplying a fraction with an integer scalar we would like to get a fraction back. However, when multiplying with a floating point number we need a floating point number as a result. The implementation is similar; just the direction is different.

class Frac(val num:Int, val den:Int) { ... val toDouble = num/den.toDouble def *(c:Int):Frac = Frac(num*c, den) // Frac * Int => Frac def *(c:Double):Double = toDouble*c // Frac * Double => Double ... } object Frac { def apply(num:Int, den:Int) = new Frac(num,den) implicit def int2Frac(num:Int):Frac = Frac(num,1) implicit def frac2double(frac:Frac):Double = frac.toDouble }

import Frac._ println(Frac(1,2) * 2.5) // prints 1.25 println(2.5 * Frac(1,2)) // prints 1.25

Alright, that it's. Of course, there is some functionality missing such as addition, subtraction and division operations. Furthermore, fractions should be normalized to the greatest common divisor as shown in Odersky's code. But I wanted to keep this example simple. To conclude let us put together what have now and see what we can do:

class Frac(val num:Int, val den:Int) extends Ordered[Frac] { require(den > 0) val toDouble = num/den.toDouble def *(that:Frac):Frac = Frac(this.num*that.num, this.den*that.den) def *(c:Int):Frac = Frac(num*c, den) def *(c:Double):Double = toDouble*c def compare(that:Frac):Int = (this.num*that.den) - (that.num*this.den) override def equals(other:Any) = other match { case that:Frac => (this eq that) || (that.num == this.num && this.den == that.den) case _ => false } override def hashCode = 13*(num+13*den) override def toString = "%d/%d" format (num,den) } object Frac { def apply(num:Int, den:Int) = new Frac(num,den) implicit def int2Frac(num:Int):Frac = Frac(num,1) implicit def frac2double(frac:Frac):Double = frac.toDouble }

import Frac._ println(Frac(1,3) == Frac(1,2)) println(Frac(1,3) < Frac(1,2)) println(Frac(1,3) * Frac(1,2)) println(Frac(1,2) * 2.5) println(2.5 * Frac(1,2)) println(Frac(1,2) * 2) println(2 * Frac(1,2))