A Deeper Look at the Scala Syntax

Scala is an object-oriented, statically-typed and functional programming language for the JVM. The strength of Scala lies in it’s powerful syntax which allows to write readable, manageable code which is short and concise – and it comes with great support for common design pattern (i.e. a special keyword for implementing the singleton design pattern).

There are plenty of good tutorials and introductions for learning Scala in the web, but only a few mention the great possibilities programmers have to extend Scala or even build an own domain specific language using Scala without being forced to use macros as seen in LISP-like languages.

One interesting feature of Scala are “blocks” which work quite different then code blocks in Java and C++ although they use the same syntax. A block in Scala is rather a sequence of expressions which is evaluated successively and it returns the value of the last expression. Just think of them as the “do” function in LISP. Blocks are surrounded by curly braces and the expressions they hold are separated by semicolons.

scala> {val x = 2; x + 5}
res0: Int = 7

Thanks to some syntactic sugar the semicolon can be replaced by a line break which becomes handy in larger blocks.

scala> {
  val x = 5
  x + 5
}
res1: Int = 10

Because blocks are just expressions they can be used, of course, like every other expression. They can be stored in variables, returned by functions and also be used as parameters for functions:

scala> println(2+5)
7

scala> println {
  val x = 2
  x + 5
}
7

The attentive reader might already have a glimpse of the potential power of such a syntax. This tiny, simple feature allows us to define functions which look and feel more like keywords of the language’s syntax. Just think of a function which measures the time a given piece of code needs to be executed. How would you write something like this in Java or even in a dynamic language like Python? In Scala this can easily be done by writing a function which expects a code block and handles it like a function which returns a value of any type to simulate lazy parameter evaluation.

def time(code: => Any):Any = {
  val time = System.currentTimeMillis
  val result = code
  println("time elapsed: " + (System.currentTimeMillis-time))
  result
}

def fib(n:Int):Int = if (n < 2) 1 else fib(n-1)+fib(n-2)

scala> time {
  fib(40)
}

time elapsed: 1020
res2: Any = 165580141
Advertisements

1 Response to “A Deeper Look at the Scala Syntax”


  1. 1 Kai Wähner August 23, 2011 at 7:43 am

    Hey Daniel,

    thanks for this very good and easy example!

    Eventually, I now understand how Scala blocks are declared and used.

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


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s





%d bloggers like this: