Add an auxilliary Rational constructor for whole numbers.

Instead of having to write new Rational(5, 1), now you can just
write new Rational(5).

Scala isn't just unicorns and kittens and rainbows, but actually
comes with some real trade-offs:

In Scala, every auxiliary constructor must invoke another
constructor of the same class as its first action. In other
words, the first statement in every auxiliary constructor
in every Scala class will have the form “this(. . . )”.  The
invoked constructor is either the primary constructor (as in
the Rational example), or another auxiliary constructor that
comes textually before the calling constructor. The net effect
of this rule is that every constructor invocation in Scala will
end up eventually calling the primary constructor of the class.
The primary constructor is thus the single point of entry of a
class.

If you’re familiar with Java, you may wonder why Scala’s rules
for constructors are a bit more restrictive than Java’s. In Java,
a constructor must either invoke another constructor of the same
class, or directly invoke a constructor of the superclass, as its
first action. In a Scala class, only the primary constructor can
invoke a superclass constructor. The increased restriction in
Scala is really a design trade-off that needed to be paid in
exchange for the greater conciseness and simplicity of Scala’s
constructors compared to Java’s.