an introductionMichel Schinz

What is Scala?Scala is a programming language that:

• coherently combines the best aspects of object-oriented and functional programming languages,

• runs on the JVM and is fully interopeable with Java – a .NET version is in the works,

• is statically typed and very concise,

• offers a high level of abstraction and good performances.

Object-oriented programming in Scala

Rational numbers

First example: model rational numbers n / d where n and d are integers, and d ≠ 0.

Provide addition, multiplication and comparison of rationals.

A class for rationals (1)class Rational(n0: Int, d0: Int) { require(d0 != 0)

private def gcd(x: Int, y: Int): Int = if (y == 0) x else gcd(y, x % y)

private val g = gcd(n0.abs, d0.abs) val n: Int = n0 / g val d: Int = d0 / g

def this(n: Int) = this(n, 1)

to be continued…auxiliary

constructor

public fields (immutable)

constructor arguments

no explicit type (Int inferred)no return

A class for rationals (2) …continued

def +(that: Rational): Rational = new Rational(this.n * that.d + that.n * this.d, this.d * that.d)

def *(that: Rational): Rational = new Rational(this.n * that.n, this.d * that.d)

override def toString: String = n +"/"+ d} parameterless

method

public method

Using rationalsscala> val r1 = new Rational(1, 3)r1: Rational = 1/3

scala> val r2 = new Rational(5)r2: Rational = 5/1

scala> r1 + r2 // or: r1.+(r2)res0: Rational = 16/3

scala> res0 * r1 // or: res0.*(r1)res1: Rational = 16/9

primary constructor call

auxiliary constructor call

inferred type

A companion for rationals

object Rational { def apply(n: Int, d: Int): Rational = new Rational(n, d) def apply(n: Int): Rational = new Rational(n)

val ZERO = new Rational(0)}

singleton

scala> Rational(2,5) + Rational.ZEROres1: Rational = 2/5

implicitly calls apply

companion object for class Rational

Ordered objects

trait Ordered[T] { def compare(that: T): Int def < (that: T): Boolean = (this compare that) < 0 def <=(that: T): Boolean = (this compare that) <= 0 def > (that: T): Boolean = (this compare that) > 0 def >=(that: T): Boolean = (this compare that) >= 0}

abstract method

type parameter

Ordered rationals

class Rational(n0: Int, d0: Int) extends Ordered[Rational] { … as before

def compare(that: Rational): Int = (n * that.d) compare (that.n * d)}

provides <, <=, > and >= methods

Cells

Second example: model mutable cells that contain a single value of some arbitrary type.

Additionally, define logging and undoable variants.

A class for generic cells

class Cell[T](val init: T) { private var v = init

def get(): T = v def set(v1: T): Unit = { v = v1 }

override def toString: String = "Cell("+ v +")"}

make init available as a field

mutable field

≈ Java’s void

A trait for logging cellstrait LoggingCell[T] extends Cell[T] { override def get(): T = { println("getting "+ this) super.get() }

override def set(v1: T): Unit = { println("setting "+ this +" to "+ v1) super.set(v1) }}

A trait for undoable cellstrait UndoableCell[T] extends Cell[T] { import collection.mutable.ArrayStack private var hist = new ArrayStack[T]()

override def set(v1: T): Unit = { hist.push(super.get()) super.set(v1) }

def undo(): Unit = super.set(hist pop)}

Mixin composition

new Cell(0)

new Cell(0) with LoggingCell[Int]

new Cell(0) with LoggingCell[Int] with UndoableCell[Int]

new Cell(0) with UndoableCell[Int] with LoggingCell[Int]

basic integer cell

logging integer cell

logging, undoable integer cell (undos are

logged)

logging, undoable integer cell (undos are

not logged)

The Scala library

Optional valuesAn optional value is either empty, or contains a single element.

Example use: as a clean replacement for null.

abstract class Option[+T] { def isEmpty: Boolean def get: T

def getOrElse[U >: T](d: =>U): U = if (isEmpty) d else get

…many more methods}

by-name parameter

bounded type parameter

variance (here co-variant)

Optional values (2)

case class Some[+T](x: T) extends Option[T] { def isEmpty = false def get = x}

case object None extends Option[Nothing] { def isEmpty = true def get = throw new …}

subtype of all types

can be matched (see later) & compiler-provided methods

Using optional values

scala> val v1 = Some("something")v1: Some[String] = Some(something)

scala> val v2 = Nonev2: None.type = None

scala> v1 getOrElse "nothing"res1: String = something

scala> v2 getOrElse "nothing"res2: String = nothing

compiler-provided factory method

compiler-provided toString method

TuplesA tuple of size n contains exactly n heterogenous elements – i.e. they can be of different types.

Example use: a function that has to return n values can return them wrapped in a single tuple.

case class Tuple2[+T1,+T2]( _1: T1, _2: T2)

case class Tuple3[+T1,+T2,+T3]( _1: T1, _2: T2, _3: T3)

etc.

Short tuple syntaxScala offers syntactic shortcuts for tuple values:

(e1, …, en) ≣ Tuplen(e1, …, en)

and for tuple types:

(T1, …, Tn) ≣ Tuplen[T1, …, Tn]

Example:

scala> val p = ("Orwell", 1984)p: (String, Int) = (Orwell,1984)scala> p._1res1: String = Orwell

arguments of case classes are fields

(Im)mutable collections

Options and tuples are immutable.

Standard collections (sequences, sets, maps) are provided in mutable and immutable variants.

Mutable collections are similar to the ones found in Java and other imperative languages.

Immutable collections are similar to the ones found in typical functional languages.

Immutable listsAn immutable list is either empty or composed of a head element and a tail, which is another list.

abstract class List[+T] { def isEmpty: Boolean def head: T def tail: List[T] def ::[U >: T](x: U): List[U] = new ::[U](x, this)

…many more methods}

Immutable lists (2)case class ::[T](val head: T, val tail: List[T]) extends List[T] { def isEmpty = false }

case object Nil extends List[Nothing] { def isEmpty = true def head: Nothing = throw new … def tail: List[Nothing] = throw new …}

Sequences, maps and setsscala> val aSeq = Seq("zero","one","two")scala> aSeq(1)res1: String = one

scala> val aMap = Map("zero" -> 0, "one" -> 1, "two" -> 2)scala> aMap("one")res2: Int = 1

scala> val aSet = Set("zero","one","two")scala> aSet("one")res3: Boolean = true

For loopsFor loops enable iteration over the elements of collections, using a syntax that is reminiscent of SQL queries.

for (user <- users if (user.isMale && user.age > 30)) yield user.name

Pattern matching

Pattern matching

Instances of case classes can easily be constructed:

scala> Some((1,2))res: Some[(Int,Int)] = Some((1,2))

Pattern matching makes deconstruction of case classes similarly easy.

Integer division

def divMod(n: Int, d: Int): Option[(Int,Int)] = { if (d == 0) None else { …compute quotient q and remainder r Some((q, r)) }}

Using integer divisiondef testDivMod(n: Int, d: Int) = divMod(n, d) match { case Some((q, r)) => println("quot: "+ q +" rem: "+ r) case None => println("<no result>") }

scala> testDivMod(5, 3)quot: 1 rem: 2scala> testDivMod(5, 0)<no result>

Pattern matching lists

def sum(l: List[Int]): Int = l match { case h :: t => h + sum(t) case Nil => 0}

Since lists are recursive, it is natural to manipulate them with recursive functions.

Furthermore, since they are defined as a disjunction of two cases (non-empty / empty list), it is natural to use pattern matching to do a case analysis.

Example: a function to sum a list of integers.

Typed patternsPattern matching can also be used to discriminate on the type of a value:

def succAny(x: Any): Any = x match { case i: Int => i + 1 case l: Long => l + 1 case other => other}

scala> succAny(2)res1: Any = 3scala> succAny("two")res2: Any = two

supertype of all types

Int and Long are not case classes

Exception handlingUnsurprisingly, exception handling is done using pattern matching:

try { val f = new FileInputStream("f.txt") println(f.read()) f.close()} catch { case _: FileNotFoundException => println("not found") case e: IOException => println("other error: " + e)}

_ is a wildcard

Functional programming in Scala

What is FP?

The functional style of programming is one that relies on mathematical functions as the basic building block of programs.

In mathematics, a function always returns the same result when applied to the same arguments.

Therefore, the functional style of programming strongly discourages the use of side-effects – i.e. variables and other kinds of mutable data.

What is a FPL?A functional programming language is one that encourages the functional style of programming by:

• offering first-class functions that can be manipulated like any other value,

• providing lightweight syntax to define arbitrarily-nested functions,

• discouraging the use of side-effects, for example by providing libraries of immutable data-structures.

Why is FP interesting?Side-effects complicate several classes of programs, like:

• concurrent programs with shared, mutable state,

• programs that need to do “time travel”, e.g. interactive programs with undo, SCMs, …

• programs that need to work on a consistent state of some data, e.g. a live backup program,

• etc.

A trait for functionstrait Function1[F, T] { f => def apply(x: F): T

def compose[F2](g: Function1[F2, F]) : Function1[F2, T] = new Function1[F2, T] { def apply(x: F2): T = f.apply(g.apply(x)) }

override def toString = "<fun>"}

new name for this

Using functions as valuesscala> val succ = new Fun[Int,Int] { def apply(x: Int) = x + 1 }succ: …with Function1[Int,Int] = <fun>scala> val twice = new Fun[Int,Int] { def apply(x: Int) = x + x }twice: …with Function1[Int,Int] =<fun>scala> succ.apply(6)res1: Int = 7scala> twice.apply(5)res2: Int = 10scala> (succ compose twice).apply(5)res3: Int = 11

Using functions as valuesscala> val succ = new Fun[Int,Int] { def apply(x: Int) = x + 1 }succ: …with Function1[Int,Int] = <fun>scala> val twice = new Fun[Int,Int] { def apply(x: Int) = x + x }twice: …with Function1[Int,Int] =<fun>scala> succ.apply(6)res1: Int = 7scala> twice.apply(5)res2: Int = 10scala> (succ compose twice).apply(5)res3: Int = 11W

orks

, but

way to

o verb

ose!

Functional syntactic sugar

scala> val succ = { x: Int => x + 1 }succ: (Int) => Int = <function1>

scala> val twice = { x: Int => x + x }twice: (Int) => Int = <function1>

scala> (succ compose twice)(5)res1: Int = 11

anonymous function

a.k.a. Function1[Int, Int]

implicit apply

Partial applicationFunction values can also be created by applying existing functions or methods to a (possibly empty) subset of their arguments:

scala> val succ: Int=>Int = _ + 1succ: (Int) => Int = <function1>

scala> val toStr: Any=>String = _.toStringtoStr: (Any) => String = <function1>

scala> toStr(0123)res0: String = 83

Collections as functions

Most collections are functions:

• Seq[T] has type Int=>T,

• Map[K,V] has type K=>V,

• Set[T] has type T=>Boolean.

This explains the common notation to access their elements: it’s simply function application!

Operating on collectionsFunctional values are ideal to operate on collections. Examples:scala> val s = Seq(1,2,3,4,5)scala> s map (_ + 1)res1: Seq[Int] = List(2, 3, 4, 5, 6)scala> s reduceLeft (_ * _)res2: Int = 120scala> s filter (_ % 2 == 0)res3: Seq[Int] = List(2, 4)scala> s count (_ > 3)res4: Int = 2scala> s forall (_ < 10)res5: Boolean = true

Project Euler: problem 8

Solving problem 8val n = "7316717653133062491922511967442…"val digits = s.toList map (_.asDigit)

def prods(l: List[Int]): List[Int] = l match { case a :: (t@(b :: c :: d :: e :: _)) => (a * b * c * d * e) :: prods(t) case _ => List() }

prods(digits) reduceLeft (_ max _)

For loops translationThe for notation is pure syntactic sugar. The example:

for (user <- users if (user.isMale && user.age > 30)) yield user.name

is automatically expanded to:users .filter(user => user.isMale && user.age > 30) .map(user => user.name)

Implicits

Scala implicits

Scala offers two notions of implicit entities that are automatically inserted by the compiler in certain contexts:

• Implicit conversions, which can be applied automatically to transform a type-incorrect expression into a type-correct one.

• Implicit parameters, which can be automatically passed to a function.

Implicit conversionsAn implicit conversion from Int to Rational can be added to the latter’s companion object:

object Rational { …as before implicit def i2r(i: Int): Rational = Rational(i)}

scala> 2 + Rational(1,3) // i2r(2) + …res2: Rational = 7/3scala> Rational(1,3) + 3 // … + i2r(3)res3: Rational = 10/3

“Pimp my library”Implicit conversions make it possible to “augment” existing classes by implicitly wrapping them – known as the Pimp my library pattern.

This technique is heavily used in the standard library to improve anemic Java classes (e.g. String, Integer, Boolean, arrays, etc.).

scala> "1337"res1: java.lang.String = 1337

scala> "1337".toIntres2: Int = 1337

strings are really Java strings

implicit conversion

Implicit parameters

def max[T](xs: T*) (implicit ord: Ordering[T]): T = xs reduceLeft ord.max

scala> max(4, -2, 12, 25, 7, -1, 2)res1: Int = 25scala> max(4, -2, 12, 25, 7, -1, 2) (Ordering.Int.reverse)res2: Int = -2scala> max(1 to 20 : _*)res3: Int = 20

repeated parameter

implicitly Ordering.Int

pass all elements as separate arguments

Working with XML data

XML literalsScala supports XML literals, which are translated to instances of various classes in scala.xml.

scala> val hello = <p>Hello <b>world</b></p>hello: scala.xml.Elem = <p>Hello <b>world</b></p>scala> val name = "Roger&Co."name: java.lang.String = Roger&Co.scala> val hello = <p>Hello <b>{ name }</b></p>hello: scala.xml.Elem = <p>Hello <b>Roger&amp;Co.</b></p>

arbitrary Scala expression

XPath-like queriesscala> val users = <users> <user name="Roger" age="12"/> <user name="Mary" age="44"/> <user name="Jean" age="12"/> </users>scala> users \\ "@name"res1: scala.xml.NodeSeq = RogerMaryJeanscala> (users \\ "@age") map (_.toString.toInt) reduceLeft (_ max _)res2: Int = 44

XML pattern matchingdef parseRow(r: xml.Node): (String, Int) = r match { case <tr><td>{ name }</td> <td>{ age }</td></tr> => (name.text, age.text.toInt) }

scala> val table = <table> <tr><td>Roger</td><td>12</td></tr> <tr><td>Mary</td><td>44</td></tr> </table>scala> (table \ "tr") map parseRowres1: Seq[(String, Int)] = List((Roger,12), (Mary,44))

Testing with ScalaCheck

Properties for rationalsThe operations we defined on rationals should satisfy several properties:

• ∀x, y ∈ Q: x + 0 = 0 + x = x

• ∀x, y ∈ Q: x + (y + z) = (x + y) + z

• etc.

ScalaCheck makes it possible to express such properties and test them on random rationals. Extensive use of implicits keep the client code very concise.

Properties for rationals

object RatProps extends Properties("Rat") { property("+ left unit") = Prop.forAll((x: Rational) => 0 + x == x) property("+ right unit") = Prop.forAll((x: Rational) => x + 0 == x) property("+ associativity") = Prop.forAll((x: Rational, y: Rational, z: Rational) => (x + y) + z == x + (y + z))}

Generating rationalsScalaCheck doesn’t know how to generate arbitrary rationals, but we can easily define a generator for them:

implicit def arbRat: Arbitrary[Rational] = Arbitrary { Gen.sized(sz => for (n <- Gen.choose(-sz, sz); d <- Gen.choose(-sz, sz) suchThat (_ != 0)) yield Rational(n, d)) }

Testing rationals% scala RatProps + Rat.+ left unit: OK, passed 100 tests. + Rat.+ right unit: OK, passed 100 tests. + Rat.+ associativity: OK, passed 100 tests.

! Rat.wrong: Falsified after 0 passed tests. > ARG_0: 1/2

When a property can be falsified (here the incorrect property ∀x ∈ Q: x = 0), the counter-example is presented:

Further reading

http://www.scala-lang.org/

Two books about Scala:

• Programming in Scala by Odersky, Spoon & Venners

• Programming Scala by Wampler & Payne

One book about functional programming:

• The Functional Approach to Programming by Cousineau, Mauny & Callaway