Now I’m continuing to the rest of your Scala posts :)

You were wondering why Ordered doesn’t use your trick. That’s because it is sometimes the case that a class T extends Ordered[U], where U is a superclass. For example,

class Person(val id: Short) extends Ordered[Person] {
def compare(other: Person) = id.toInt – other.id
}

Now consider

class Student(val major: String, id: Short) extends Person(id)

You couldn’t have Student be a subtype of Ordered[Student].

scala> abstract class Dimension[T <: Dimension[T]](val value: Double, val name: String, val coef: Double) {
protected def create(value: Double, name: String, coef: Double): T
def +(x: Dimension[T]): T = create(value + coef * x.value / x.coef, name, coef)
def -(x: Dimension[T]): T = create(value – coef * x.value / x.coef, name, coef)
override def toString(): String = value + ” ” + name
}

class Time(value: Double, name: String, coef: Double) extends
| Dimension[Time](value, name, coef) {
| protected def create(a: Double, b: String, c: Double) = new Time(a, b, c)
| }
defined class Time

scala> class Mass(value: Double, name: String, coef: Double) extends
| Dimension[Time](value, name, coef) {
| protected def create(a: Double, b: String, c: Double) = new Time(a, b, c)
| }
defined class Mass

That compiles. Scala doesn’t mind that Time and Mass are two different things because they both descend from Dimension. What I was trying to achieve in this code is an abstract class whose descendents can only be added and subtracted with themselves. Mass can only be added to mass, and never to Time.

The type bound only allows us to restrict based on which types descend from some known type. A self type provides an object with a handle specifically to its own type, and provides its descendents with a handle to their own types. Using the above code using type bounds, we could do the following:

scala> abstract class TimeUnit(name: String, coef: Double) {
| def apply(value: Double) = new Time(value, name, coef)
| def apply(orig: Time) = new Time(0, name, coef) + orig
| }
defined class TimeUnit

scala> abstract class MassUnit(name: String, coef: Double) {
| def apply(value: Double) = new Mass(value, name, coef)
| def apply(orig: Time) = new Mass(0, name, coef) + orig
| }
defined class MassUnit

scala> object Second extends TimeUnit(“seconds”, 1.0)
defined module Second

scala> object Kilogram extends MassUnit(“kg”, 1.0)
defined module Kilogram

scala> Second(1.0) + Kilogram(1.0)
res0: Time = 2.0 seconds

scala> Kilogram(1.0) + Second(1.0)
res1: Time = 2.0 kg

abstract class Dimension[T <: Dimension[T]]

Maybe that's equally mysterious :-)

scala> 1 to 325000
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3…
scala> res0.foldRight(“”)((x,y)=>”X”)
res1: java.lang.String = X

scala> res0.toList.view
res2: java.lang.Object with scala.collection.SeqView[Int,List[Int]] = SeqView(…)

scala> res2.foldRight(“”)((x,y)=>”X”)
res3: java.lang.String = X

congratulations for your Scala blogs. I found this one using Google. It forwarded me to your foldLeft explanation. That one forwarded me to your Tail-Recursion basics. While reading them, Google forwarded me to your “Null, null, Nil, …” blog.

These blogs are very good, because they are natural and easy to understand! The main problem of Scala is the lack of good, easy to ready blogs and books, still. Odersky and some others wrote books with good contents, but these books are only good as reference book, because they are to difficult to understand IMO.

Best regards,
Kai Wähner (Twitter: @KaiWaehner)