Scala

Overview

• is a functional, object-oriented, extensible language.
• was designed by Martin Odersky.
• was first released in 2003.
• interoperates wth Java.
• has many cool features: pattern matching, comprehensions, closures, regexes, annotations, memo functions, traits, streams, monads, polymorphism, parser combinators, actors, mailboxes, threads, paths, algebraic types, semicolon inference, type inference, lightweight classes, extensible APIs, and companion objects.
• does NOT have: primitive types, static members, a continue statement, interfaces, raw types, wilcards, or enums.

In Scala everything is an object, even numbers and functions.

Scala 2.9.1 was released on 2011-08-29.

Useful Links

• Scala Language Home Page
• Scala Tutorial for Java Programmers
• Scala By Example
• Scala Collections API

Getting Started

Like most modern programming languages, you can execute programs stored in files or you can use the REPL (Read-Eval-Print Loop).

To use the REPL invoke scala with no arguments:

You can put your script in a file, and invoke scala with the filename:

println("Hello, world")

If you need commandline arguments, use the args array:

// Print a greeting for the one whose name is given as the first commandline argument.

print("Hello");
if (args.isEmpty || args(0).trim.isEmpty) {
  println
} else {
  println(", " + args(0))
}

Your script can also be comprised of an object with a method called main taking in an array of strings for the arguments:

object CodepointComputer {

  def codepointsFor(s: String) = {
    s.toList.map(c => c.toInt)
  }

  def main(args: Array[String]) {
    if (args.isEmpty || args(0).trim.isEmpty) {
      println("Missing argument")
    } else {
      println(codepointsFor(args(0)))
    }
  }
}

It works as before:

In addition, this style allows you to compile and interpret separately:

A Few Simple Scripts

Let's continue getting acquainted with the look and feel of Scala scripts:

import java.util.{Date, Locale}
import java.text.DateFormat._

val now = new Date
val frenchDateForatter = getDateInstance(LONG, Locale.FRANCE)
println(frenchDateForatter format now)
println(getDateInstance(LONG, Locale.US) format now)
println(getDateInstance(SHORT, Locale.CHINA) format now)

// A script to write the Fibonacci numbers up to and including the first commandline argument.

object FibonacciLister {
  def main(args: Array[String]) {
    val n = args(0).toInt
    var (a, b) = (0, 1)
    while (b <= n) {
      print(b + " ")
      var olda = a
      a = b
      b = a + b
    }
    println
  }
}

object TimerExample {

  /**
   * Runs the passed in function pausing approximately one second in between calls,
   * as long as the function returns true.
   */
  def oncePerSecond(callback: () => Boolean) {
    while (callback()) {
      Thread sleep 1000
    }
  }

  /**
   * Counts down from 10 to 1, approximately once per second.
   */
  def main(args: Array[String]) {
    var count = 10;
    oncePerSecond(() => {println(count); count -= 1; count > 0})
  }
}

Types

Good terms to know:

• basic types: those with no internal structure
• reference types
• user-defined types

Basic Types

Functions

import java.util.Arrays

def addSeven(x: Int) = x + 7
def multiplier(n: Int) = (x: Int) => x * n
def timesFour = multiplier(4)
def twice(f: (Int) => Int, x: Int) = f(f(x))
var timesThree = (x: Int) => x * 3
val collatz = (n: Int) => if (n % 2 == 0) n / 2 else 3 * n + 1

println(addSeven(5));
println(timesFour(10));
println(timesThree(10));

var n = 27
var a: Array[Int] = Array(n)
while (n != 1) {
  n = collatz(n)
  a ++= Array(n)
}
println(Arrays.toString(a))

Classes

Writing Classes

Here are a couple starter classes:

/**
 * A simple immutable circle with a center point and a radius.
 */
class Circle(x: Double, y: Double, radius: Double) {
  def center = (x, y)
  def area = math.Pi * radius * radius
  def perimeter = 2.0 * math.Pi * radius
  def move(dx: Double, dy: Double) = new Circle(x + dx, y + dy, radius)
  def expand(factor: Double) = new Circle(x, y, radius * factor)
  override def toString = "Circle at (" + x + "," + y + ") with radius " + radius
}

/**
 * A simple mutable circle with a center point and a radius.
 */
class MutableCircle(private var x: Double, private var y: Double, private var radius: Double) {

  def center = (x, y)

  def area = math.Pi * radius * radius

  def perimeter = 2.0 * math.Pi * radius

  def move(dx: Double, dy: Double) = {
    x += dx
    y += dy
    this
  }

  def expand(factor: Double) = {
    radius *= factor
    this
  }

  override def toString = "MutableCircle at (" + x + "," + y + ") with radius " + radius
}

Compile them, then let's see them in action:

Subclasses

Here's an abstract class for animals and three concrete subclasses.

abstract class Animal(name: String) {
  def speak = name + " says " + sound
  def sound: String
}

class Cow(name: String) extends Animal(name) {
  override def sound() = "moooooo"
}

class Horse(name: String) extends Animal(name) {
  override def sound() = "neigh"
}

class Sheep(name: String) extends Animal(name) {
  override def sound() = "baaaa"
}

var h = new Horse("CJ")
println(h.speak)
var c = new Cow("Bessie")
println(c.speak)
println(new Sheep("Little Lamb").speak)

Traits

Case Classes and Pattern Matching

Generics

Lists

Someone's blog post

For Comprehensions

A for comprehension is just syntactic sugar for certain (chains of) method calls. Examples are better than explanations here.

scala> val a = List(3, 6, 5, 7, 8, 1, 2, 3, 2, 14, 8)
a: List[Int] = List(3, 6, 5, 7, 8, 1, 2, 3, 2, 14, 8)

scala> a.map(x => x * 3)
res0: List[Int] = List(9, 18, 15, 21, 24, 3, 6, 9, 6, 42, 24)

scala> a.map(_ * 3)
res1: List[Int] = List(9, 18, 15, 21, 24, 3, 6, 9, 6, 42, 24)

scala> for (x <- a) yield x * 3
res2: List[Int] = List(9, 18, 15, 21, 24, 3, 6, 9, 6, 42, 24)

scala> a.filter(_ < 5).map(_ * 3)
res3: List[Int] = List(9, 3, 6, 9, 6)

scala> for (x <- a; if x < 5) yield x * 3
res4: List[Int] = List(9, 3, 6, 9, 6)

scala> a.filter(_ < 5).foreach(x => print(x * 3))
93696
scala> for (x <- a; if x < 5) {print(x * 3)}
93696
scala> for (x <- 0 until 4; y <- 0 until 4) yield (x, y)
res7: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((0,0), (0,1), (0,2), (0,3),
(1,0), (1,1), (1,2), (1,3), (2,0), (2,1), (2,2), (2,3), (3,0), (3,1), (3,2), (3,3))

scala> (0 until 4).flatMap(x => (0 until 4).map(y => (x, y)))
res8: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((0,0), (0,1), (0,2), (0,3),
(1,0), (1,1), (1,2), (1,3), (2,0), (2,1), (2,2), (2,3), (3,0), (3,1), (3,2), (3,3))

Mutable State

Streams

Lazy Values

Implicit Parameters

Concurrency

Unit Testing

Many unit testing frameworks exist for Scala. One of the most popular is ScalaTest. Start with the Quick Start. You'll want to start with FunSuite.

class Point(val x: Double, val y: Double) {
  def distanceToOrigin() = math.sqrt(x * x + y * y);
  override def toString = "(" + x + "," + y + ")"
}

import org.scalatest.FunSuite

class PointSuite extends FunSuite {

  test("construction") {
    val p = new Point(3, -4)
    assert(p.x === 3)
    assert(p.y === -4)
  }

  test("making strings") {
    val p = new Point(3, -4)
    assert(p.toString() === "(3.0,-4.0)")
  }

  test("distance to origin") {
    val p = new Point(3, -4)
    assert(p.distanceToOrigin() === 5)
  }
}

To run:

$ scalac -cp scalatest-1.6.1.jar point.scala pointtest.scala
$ scala -cp scalatest-1.6.1.jar org.scalatest.tools.Runner -p . -o -s PointSuite

Language and Library Reference

In Scala 2.9.1, there are 57 packages in the Scala Standard Library.