Here are my notes on learning Scala:

•  Not a lot of tool support yet.  JEdit syntax highlighting works OK, as do some other editors. Eclipse plugin provides more capability, but it is slow.
• Environment variables:
• SCALA_HOME=/path/to/scala/dir

Notes on the language proper:

Hello World:

object HelloWorld {    def main(args: Array[String]) {        println("Hello, world!")    }}

object defines a singleton class instance.  Every program has a function named main inside a singleton object.

def defines a function or an expression without evaluating it; it does not evaluate its RHS.

Val defines a constant; it evaluates its RHS.

Formal parameter definition should always include a type. (Array[String] for the main function.)

Function calls are call-by-value by default.  Formal parameters with ": =>" instead of just ":" are call-by-name.

Every statement returns a value.

"return val" is the same as "val" at the end of a function.

Semicolons may be used as statement terminators.

Function definitions look like this:

def funcname(parm: ParmType):FuncType = {
statements;
}

You can omit the surrounding {} if the function body is a single statement.

You can omit FuncType if it is obvious to the compiler.

Conditions (e.g. in an if-statement) must be surrounded by parenthesis, as in C and Java.

You can nest functions (in order to scope the names).

Tail-recusion is optimized for "directly tail-recursive" calls.  e.g. This gets optimized:

    def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)

... but this does not (due to the need to multiply AFTER the recursion returns).

    def factorial(n: Int): Int = if (n == 0) 1 else n * factorial(n 1)

Named functions can be passed by name too ("First-class functions"), as can anonymous functions.

Here is an anonymous function in use:

def blarfle(a: Int, b: Int): Int = sum((x: Int) => x * x, a, b)


The function header is "(x: Int)", so it is a function that takes a single, integer parameter. The body of the function is "x * x".

Sometimes you can get away with omitting the type (if the compiler can figure it out), as in:

def blarfle(a: Int, b: Int): Int = sum((x) => x * x, a, b)


And, whenever your argument list is just "(x)" it can be rewritten as "x" giving:

def blarfle(a: Int, b: Int): Int = sum(x => x * x, a, b)


Sometimes you'll run into a function that looks like this:

def sum(f: Int => Int): (Int, Int) => Int = {
def sumF(a: Int, b: Int): Int =
if (a > b) 0 else f(a) + sumF(a + 1, b)
sumF
}


This says that 'sum' is a function that take a function (the argument 'f') that takes an Int parameter and returns an Int result;], and the function 'sum' returns a function of type "(Int, Int)=> Int)". In other words, 'sum' is a function factory that takes one function as its argument, and it generates a function that takes two Ints (and returns an Int).

One way to use sumF would be to do something like:

  def g = sum((x) => x * x)
g(1,3)


... which calls 'sum' to generate a function that sums squares, naming the new function 'g', and then calls 'g' with 1 and 3 as parameters.

Sometimes Scala can't really tell that this is what you are trying to do, and it complans in your def of g. You solve that problem like so:

  def g = sum((x) => x * x) _
g(1,3)


... which uses the trailing underscore to tell Scala, "Hey! Don't worry -- this call of 'sum' just returns a function and I promise to pass the right arguments to that function when I call it. (I think.)

<pFor the ultimate in brevity, you can define g and call it in a single line:</p>

sum(x => x * x)(1, 10)


The "sum(x => x * x)" generates the new (unnamed) function and the "(1, 10)" calls it with the arguments 1 and 10.

more soon