The comparison goes like this: you have the same program (OO Hello World) implemented in 19 languages using exactly the same features and rules) and then compare them based on some metrics. The comparisons so far are between Keywords and Lines of code

Fantom:
http://carlosqt.blogspot.com/2010/07/oo-hello-world-fantom.html
Scala:
http://carlosqt.blogspot.com/2010/07/oo-hello-world-scala.html

Then you have:
http://carlosqt.blogspot.com/2010/07/how-many-keywords-do-you-type-in-your.html
and
http://carlosqt.blogspot.com/2010/07/how-many-lines-to-code-same.html

another great comment!
You say “expectations for some reason go higher when it starts looking like a real programming language construct, which perhaps is unreasonable.”
You’re right, but I think also that if you give more power you need more safety too. Scala is like a Ferrari race car: as it can run so much, I expect it has good brakes too!!!


.unless |->Bool| {i == 0}


can occur on a line for itself. This is also the case in Scala if one uses the dot notation.

Below is the example in Scala with several uses, so one can see the different scenarios.

First the definition of the loop construct:

object Loop {
  def loop(stmt : => Unit) : Unless = {
    new Unless(stmt)
  }

  protected class Unless(stmt : => Unit) {
    def unless(cond : => Boolean) {
      stmt
      if(!cond)unless(cond)
    }
  }
}

import Loop._

Then the calls:

// call 1 (using mixfix notation - works):                                                                                        

var i : Int = 10;
loop {
  println(i)
  i = i - 1
} unless (i == 0)

// call 2 (also using mixfix notation, but with unless on a line for itself - gives a compile time error):                                                                           

i = 10;
loop {
  println(i)
  i = i - 1
}
unless (i == 0) // occurs on a line for itself - does not work

// Also, if this last line is left out, no error message is given.
// This is how other OO languages work. Not a problem as such in OO languages,
// but it does reduce the value of this mixfix notation for writing DSLs. It makes a DSL unsafe to use.

//  call 3 (using dot notation - works as expected):                                                                                          

i = 10;
loop {
  println(i)
  i = i - 1
}.unless(i == 0)

// call 4 (using dot notation, with unless on a line for itself - works):                                                                                           

i = 10;
loop {
  println(i)
  i = i - 1
}.
unless(i == 0) // occurs on a line for itself

Scala offers this mixfix notation for defining DSLs, and it looks very appealing. However, one can
provide only a partial instantiation of a DSL construct and the Scala compiler will be happy. We normally accept this in the case of dot-notation (that’s how it is in Java and Python) but our expectations for some reason go higher when it starts looking like a real programming language construct, which perhaps is unreasonable.
Something to think about. Could one think of imposing “static liveness” constraints? Like: ‘this intermediate object shouldnever be the result of a statement’.

Note that this problem can be avoided if instead we define the loop-unless construct as a curried function:

def loop_unless(stmt : => Unit)(cond : => Boolean) {
  stmt
  if(!cond)loop_unless(stmt)(cond)
}

Then one can write:

i = 20;
loop_unless {
  println(i)
  i = i - 1
} (i == 0)

However, if we write:

i = 20;
loop_unless {
  println(i)
  i = i - 1
}

leaving out the second parameter, the compiler will complain. This approach currently seems the safest way to
define DSLs in Scala.