Oop2010 Scala Presentation Stal

Introduction toCoding in Scala is fun!
OOP 2010
Dr. Michael Stal
Michael.Stal@siemens.com

Objectives of this Presentation
Introduce core concepts of Scala
Showing you the benefits of combining OO with functional programming
Illustrating the language in a pragmatic way preferring code over theory
But not to cover every available aspect or to cover aspects in full detail
For instance, we won‘t cover Java/Scala Interop, Views, Equality Semantics, Unit Testing, Annotations
Page 2

Introduction
Scala created by the team of Martin Odersky at EPFL
„Scala“ means „Scalable Language“
„Scalable“ means:
the same language concepts for programming in the small & large
In Scala this is achieved in a pragmatic way by combining
Object Oriented Programming with
Functional Programming
Scala is a statically typed language like Java
All types are objects
Page 3
Martin Odersky, Source: http://lamp.epfl.ch/~odersky/

Object-Oriented & Functional Programming
Object-Oriented Programming
Abstraction using Classes and Interfaces
Refinement using subtyping and inheritance (Remember the Liskov Substitution Principle!)
Dynamics through polymorphism
Functional Programming
Higher Order Functions as First-Class Entities
ADTs (Abstract Data Types) following algebraic conventions
Pattern matching
Parametric polymorphism (generic types)
Page 4
SCALA

Core Properties of Scala (see Programming in Scala)
Scala is compatible: runs on JVM, interoperability with Java
Scala is concise: More compact code because removal of Java boilerplate code and powerful libraries
Scala is high-level: Higher level of abstraction by combining OO with functional programming
Scala is statically typed
Page 5
Scala‘s Roots:
Java, C#
Smalltalk, Ruby
Beta, Simula, Algol
ML
Erlang

A small Appetizer - Hello, Scala!
Page 6
Type
Inference
Immutable values
Classes
class HelloWorldClass (val name: String) {
def print() = println("Hello World of " + name)
}
object HelloWorldMain {
def main(args: Array[String]): Unit = {
val hello = new HelloWorldClass("Scala")
hello print
}
}
=> Hello World of Scala
Singletons
Look Ma,
no semicolons
No brackets required!

Stairway to Heaven – First Steps using Scala
This source code file may be compiled using scalac und run using scala:
scalac HelloWorldMain.scala
scala HelloWorldMain
Note: the source file must be named like the main object to be executed
You may run an interpreter by using the following command line instead
scala HelloWorldMain.scala
In this case you may also use plain Scala scripts (no classes or objects required)
Or, even better, you might use an IDE like Idea, Netbeans, or Eclipse
Page 7

A more advanced example (1) (from Venkat Subramanian‘s book Programming Scala, pp.5)
Page 8
import scala.actors._
import Actor._
val symbols = List( "AAPL", "GOOG", "IBM", "JAVA", "MSFT")
val receiver = self
val year = 2009
symbols.foreach {
symbol => actor { receiver ! getYearEndClosing(symbol, year) }
}
val (topStock, highestPrice) = getTopStock(symbols.length)
printf("Top stock of %d is %s closing at price %f ", year, topStock, highestPrice)
def getYearEndClosing(symbol : String, year : Int) = {
val url = new
java.net.URL("http://ichart.finance.yahoo.com/table.csv?s=" +
symbol + "&a=11&b=01&c=" + year + "&d=11&e=31&f=" + year + "&g=m")
val data = io.Source.fromURL(url).mkString
val price = data.split(" ")(1).split(",")(4).toDouble
(symbol, price)
} // .. to be continued

A more advanced example (2)(from Venkat Subramanian‘s book Programming Scala, pp.5)
Run this within interpreter mode scala TopScala.scala
After the end of the talk return to this example and check whether you better understand it
Page 9
// continued ...
def getTopStock(count : Int) : (String, Double) = {
(1 to count).foldLeft("", 0.0) { (previousHigh, index) =>
receiveWithin(10000) {
case (symbol : String, price : Double) =>
if (price > previousHigh._2) (symbol, price)
else previousHigh
}
}
}
// will result in =>
// Top stock of 2009 is GOOG closing at price 619,980000

Scala Type Hierarchy
Page 10
Scala uses a pure object-oriented type system
Every value is an object
Two types: values and references
Any is parent class of all classes, Nothing subclass of all classes
Basic
types like in
Java
Source: Scala Reference Manual

First Class Scala
Page 11
born and
id will be
public fields
Main constructor
Classes in Scala contain fields, methods, types, constructors
Visibility is public per default
class CatID(val id : Int) //that's a whole class
class Cat(val born: Int, val id: CatID) {
private var miceEaten: Int = 0
def digested() = miceEaten
def hunt(miceCaught: Int)
{ miceEaten += miceCaught }
}
object ScalaClasses {
def main(args: Array[String]) {
val id = new CatID(42)
val tom = new Cat(2010, id)
tom.hunt(3)
tom hunt 2
println(“cat was born in “ + tom.born)
println(tom.digested)
}
} // => 5 < > Tom was born in 2010
definition
of methods
No brackets
required

Class Constructors
Page 12
class Complex (r : Double, i: Double) {
println("Constructing a complex number")
val re = r
val im = i
def this(r : Double) = this(r,0)
override def toString =
re + (if (im < 0) "-" + (-im)
else "+" + im) + "*i"
...
}
Belongs to
Primary
constructor
Auxilliary
constructorsmust call
primary

Immutable and Mutable Objects
Scala provides immutable objects (functional programming) but also mutable objects
Immutability has many benefits
Reduction of race conditions in concurrent programs
Protection against unwanted modification
Scala provides mutable & immutable versions of collection types
Mutable objects are important to address objects that are supposed to change their state, but use them with care
Page 13
class Person(var name: String)
object ImmutabilityDemo {
def main(args:Array[String]) = {
val s = "Michael"
s = "Bill" // error
var t = "Michael“ // t variable
t = "Bill" // ok
val c = new Person("Bill")
c = new Person("Tom") // error
// ok - c itself unchanged:
c.name = "Tom"
}
}

Inheritance
In Scala classes can be derived from at most one base class
Classes may be abstract
You need to indicate whether you override inherited methods
Page 14
abstractclass Shape {
type Identifier = Int // defining types
def getID() : Identifier = 42
def draw() : String // abstract method
}
class Circle (val cx: Double, val cy: Double, val r: Double) extends Shape {
val id : Identifier = getID()
override def draw() : String = "I am a Circle"
}

Companion Objects and Standalone Objects
We already saw standalone objects
Objects are singletons
If you need static fields or methods for a class, introduce a companion class with the same name
Convention: apply() methods may be provided as factory methods
Page 15
class Cat private (val born : Int, val id: CatID) {
...
private def this(id: CatID) = this(2010, id)
...
} // all constructors are private
object Cat { // this is the companion object of Cat
def apply(born: Int, id: CatID) = new Cat(born, id)
def apply(id: CatID) = new Cat(id) // factory method
def whatCatsDo() = "Sleep, eat, play"
}
object ScalaClasses { // Standalone Object
val id = new CatID(43)
val pussy = Cat(id) // no new required
println("Pussy was born in " + pussy.born)
println(Cat.whatCatsDo) // like static in Java
}
}

Application Base Class
For experimenting with Scala use the base class Application
Just compile this with: scalac ObjDemo.scala
And run it with: scala ObjDemo
Useful abbreviation if you do not need to deal with command line arguments
Page 16
Inheritance
object ObjDemoextends Application {
val s: String = "Michael"
println(s) // => Michael
}

Traits
Classes and instances may mix-in additional functionality using traits
Traits represent an abstraction between interfaces and classes
Using traits we can easily live with the single-inheritance restriction
You may use also traits via anonymous classes:
val x = new Identity{}
x.name = "UFO"
println(x.whoAmI)
Page 17
trait Identity {
var name: String=""
def whoAmI() : String = name
}
class Person extends Identity
class Animal
object TraitDemo {
val p = new Person
p.name = "Michael"
println(p.whoAmI)
val a = new Animal with Identity
a.name = "Kittie"
println(a.whoAmI)
}
} // => Michael < > Kittie

Traits and Virtual Super: Inheritance Linearization
Page 18
abstract class Processor { def process() }
trait Compressor extends Processor { // trait only applicable to Processor subclass
abstract override def process() = { println("I am compressing"); super.process }
}
trait Encryptor extends Processor { // only applicable to Processor subclass
abstract override def process() = { println("I am encrypting"); super.process}
}
class SampleProcessor extends Processor { // subclass of Processor
override def process() = println("I am a Sample Processor")
}
object traitsample2 {
def main(args:Array[String]) = { // mixing in a trait to an object:
val proc1 = new SampleProcessor with Compressor with Encryptor
proc1.process// Encryptor.process=>Compressor.process
} // => SampleProcessor.process
}
Note: abstract override for a trait method means the actual subclass of Processor will provide a concrete implementation of that method!

Scala Basics: if Statements
If statements are expressions themselves, i.e. they have values
Page 19
import java.util._
if (1 + 1 == 3)
println(“strange world”)
else {
println(“everything’s ok”)
}
val res = if ((new Random().nextInt(6) + 1) == 6)
"You win!"
else
"You lose!"

Scala Basics: for Comprehensions (1)
A for comprehension is like a for loop. It lets you traverse a collection, return every object in a temporary variable which is then passed to an expression. You may also specify nested iterations:
You can specify filters for the collection elements
Page 20
val aList = List(1,2,3,4,5,6)
for (i <- aList) println(i) // => 1 < > 2 ...
val dogs = Set("Lassie", "Lucy", "Rex", "Prince");
for (a <- dogs if a.contains("L")) println(a)
// => “Lassie” < > “Lucy”

Scala Basics: for Comprehensions (2)
Yield allows to create new collections in a for comprehension:
You can specify filters for the collection elements
Page 21
var newSet = for {
a <- dogs
if a.startsWith("L")
} yield a
println(newSet) // Set(Lassie, Lucy)
for {
i <- List(1,2,3,4,5,6)
j = i * 2 // new variable j defined
} println(j) // => 2 < > 4 < > 6 ...

Scala Basics: Other loops
Scala supports while and do-while loops
But generator expressions such as (1 to 6) incl. 6 or (1 until 6) excl. 6 together with for make this much easier
Note: The reason this works is a conversion to RichInt where to is defined as a method that returns an object of type Range.Inclusive, an inner class of Range implementing for comprehensions
Page 22
var i = 1
while (i <= 6) {
println(i)
i += 1
} // = 1 < > 2 < > 3 ...
for (i <- 1 to 6) println(i)

Scala Basics: Exception handling
try-catch-finally available in Scala but throws isn‘t
catching checked exceptions is optional!
catch-order important as in Java, C++ or C#
Page 23
def temperature(f: Double) {
if (f < 0) throw new IllegalArgumentException()
}
try {
println("acquiring resources")
temperature(-5)
}
catch {
case ex: IllegalArgumentException => println("temperatur < 0!")
case _ => println("unexpected problem")
}
finally {
println("releasing resources")
}

Inner Classes
You may define inner classes as in Java
Special notation (<name> =>) for referring to outer class this from an inner class: you might also use <outerclass>.this instead
Page 24
class Element (val id: String){ elem =>
class Properties { // inner class
type KV = Tuple2[String, Any]
var props: List[KV] = Nil
def add(entry: KV) { props = entry :: props }
override def toString = {
var s: String = ""
for (p <- properties.props) s = s + p +" "
s
}
}
override def toString = "ID = " + id + " " + properties
val properties = new Properties
}
object InnerClassDemo extends Application {
val e = new Element("Window")
e.properties.add("Color", "Red")
e.properties.add("Version", 42)
println(e.toString)
}

Imports and Packages
We can partition Scala definitions into packages:
A package is a special object which defines a set of member classes, objects and packages. Unlike other objects, packages are not introduced by a definition
Importing packages works via import statements – almost like in Java
Packages scala, java.lang, scala.Predefare automatically imported
Page 25
package MyPackage1 {
class Person(val name: String)
class Animal(val name: String)
}
import MyPackage1._
object PacDemo extends Application {
val person = new Person("Michael")
println(person name)
}
import p._ all members of p (this is analogous
to import p.* in Java).
import p.x the member x of p.
import p.{x => a} the member x of p renamed as a.
import p.{x, y} the members x and y of p.
import p1.p2.z the member z of p2, itself member of p1.

Advanced Types: Lists
Collection Type: List
Page 26
object ListDemo {
def main(args:Array[String]) {
val l1 : List[Int] = Nil // empty List
val l2 = List[Int](1,2,3,4,5) // list with 5 elements
val l3 = 0 :: l2 // add 0 to the list
val l4 = List[Int](0,1,2) ::: List[Int](3,4,5) // concat 2 lists
println("Top Element: " + l4.head) // => 0
println("Rest of list: " + l4.tail) // => List(1,2,3,4,5)
println("Last Element: " + l4.last) // => 5
l4.foreach { i => println(i) } // => 1 < > 2 < > 3 ...
}
}
Foreach traverses a list and passes each element found to the closure passed as argument

Advanced Types: Sets
Collection Type: Set
Page 27
object SetDemo {
val s1 = Set[Int](1,2,3,4,5) // we could also use = Set(1,2,3,4,5)
val s2 = Set[Int](2,3,5,7)
println(s2.contains(3)) // => true
val s3 = s1 ++ s2 // union
println(s3) // => Set(5,7,3,1,4,2)
vals4 = s1 & s2 // intersection: in earlier versions **
println(s4) // Set(5,3,2)
}
}

Advanced Types: Maps
Collection Type: Map
Page 28
object MapDemo {
val m1 = Map[Int, String](1 -> "Scala", 2->"Java", 3->"Clojure")
valm2 = m1 + (4 -> "C#") // add entry
println(m2 + " has size " + m2.size)
//=> Map(1->Scala,…) has size 4
println(m1(1)) // => Scala
val m3 = m2 filter { element => val (key, value) = element
(value contains "a") }
println(m3) // => Map(1->Scala, w->Java)
}
}

Advanced Types: Options
object DayOfWeek extends Enumeration {
val Monday = Value("Monday") //argument optional
val Sunday = Value("Sunday") //argument optional
}
import DayOfWeek._
object OptionDemo {
def whatIDo(day: DayOfWeek.Value) : Option[String] =
{
day match {
case Monday => Some("Working hard")
case Sunday => None
}
}
println(whatIDo(DayOfWeek.Monday))
println(whatIDo(DayOfWeek.Sunday))
} //=> Some(„Working Hard“) < > None
}
The Option type helps dealing with optional values
For instance, a search operation might return a result or nothing
We are also introducing Enumerationtypes
Page 29

Advanced Types: Regular Expressions
Type: Regex introduces well-known regular expressions
Page 30
With this syntax strings remain formatted as specified and escape sequences are not required
object RegDemo {
val pattern = """dd.dd.dddd""".r
val sentence = “X was born on 01.01.2000 ?"
println (pattern findFirstIn sentence) // => Some(01.01.2000)
}
}
Note: the „r“ in “““<string>“““.r means: regular expression

Advanced Types: Tuples
Tuples combine fixed number of Elements of various types
Thus, you are freed from creating heavy-weight classes for simple aggregates
Page 31
println( (1, "Douglas Adams", true) )
def goodBook = {
("Douglas Adams", 42, "Hitchhiker's Guide")
}
println ( goodBook._3 ) // get third element
// => (1, Douglas Adams, true)
// => Hitchhiker‘s Guide

Advanced Types: Arrays
Arrays hold sequences of elements
Access very efficient
Page 32
val a1 = new Array[Int](5) // initialized with zeros
val a2 = Array(1,2,3,4,5) // initialized with 1,2,3,4,5
println( a2(1) ) // => 2
a2(1) = 1 // => Array (1,1,3,4,5)
Note:
In Scala the assignment operator = does not return a reference to the left variable (e.g., in a = b).
Thus, the following is allowed in Java but not in Scala: a = b = c

Smooth Operator
In Scala operator symbols are just plain method names
For instance 1 + 2 stands for 1.+(2)
Precedence rules:
All letters
|
^
&
< >
= !
:
+ -
* / %
Page 33
class Complex(val re:Double, val im:Double) {
def +(that: Complex) : Complex = {
new Complex(this.re + that.re,
this.im + that.im)
}
override def toString() : String = {
re + (if (im < 0) "" else "+") + im +"i"
}
}
object Operators {
val c1 = new Complex(1.0, 1.0)
val c2 = new Complex(2.0, 1.0)
println(c1+c2)
}
} // => (3.0+2.0i)

Conversions
Implicit converters allow Scala to automatically convert data types
Suppose, you‘d like to introduce a mathematical notatation such as 10!
Using implicit type converters you can easily achieve this
Page 34
object Factorial {
def fac(n: Int): BigInt =
if (n == 0) 1 else fac(n-1) * n
class Factorizer(n: Int) {
def ! = fac(n)
}
implicit def int2fac(n: Int) = new Factorizer(n)
}
import Factorial._
object ConvDemo extends Application {
println("8! = " + (8!)) // 8 will be implicitly converted
} // => 40320

Parameterized Types in Scala
Classes, Traits, Functions may be parameterized with types
In contrast to Java no wildcards permitted – parameter types must have names
Variance specification allow to specify covariance and contravariance
Page 35
trait MyTrait[S,T] {
def print(s:S, t:T) : String = "(" + s + "," + t + ")"
}
class MyPair[S,T] (val s : S, val t : T)
extends MyTrait [S,T] {
override def toString() : String = print(s,t)
}
object Generics {
val m = new MyPair[Int,Int](1,1)
printf(m.toString())
}
} // => (1,1)

Small Detour to Variance and Covariance / Type Bounds
If X[T] is a parameterized type and T an immutable type:
X[T] is covariant in T if: S subTypeOf T => X[S] subTypeOf X[T]
X[T] is contravariant in T if: S subTypeOf T => X[S] superTypeOf X[T]
In Scala covariance is expressed as X[+T] and contravariance with X[-T]
Covariance is not always what you want: Intuitively we could assign a set of apples to a set of fruits. However, to a set of fruits we can add an orange. The original set of apples gets „corrupted“ this way
Example List[+T]: Covariance means a List[Int] can be assigned to a List[Any] because Int is subtype of Any
Upper/Lower Bounds may be specified:
In the following example D must be supertype of S:
def copy[S, D>:S](src: Array[S], dst: Array[D]) = { ...
Page 36

Functional Aspects: Functions and Closures
In Scala Functions are First-Class Citizens
They can be
passed as arguments
assigned to variables: val closure={i:Int => i+42}
Nested functions are also supported
Page 37
object scalafunctions {
def add(left:Int,right:Int, code:Int=>Int)=
{
var res = 0
for (i<-left to right) res += code(i)
res
}
println(add(0,10, i => i))
println(add(10,20, i => i % 2 ))
}
}
=>
55
5

Functional Aspects: Call-by-Name
If a parameterless closure is passed as an argument to a function, Scala will evaluate the argument when the argument is actually used
This is in contrast to call-by-value arguments
A similar effect can be achieved using lazy (value) evaluation:
lazy val = <expr>
Page 38
import java.util._
object CbNDemo {
def fun(v: => Int) : Int = v
// v is a Call-by-Name Parameter
def v() : Int = new Random().nextInt(1000)
println( fun(v) )
println( fun(v) )
}
} // => 123 < > 243

Functional Aspects: Currying (1)
Currying means to transform a function with multiple arguments to a nested call of functions with one (or more) argument(s)
def fun(i:Int)(j:Int) {}
(Int)=>(Int)=>Unit=<function1>
Page 39
def fun1(i:Int, j:Int) : Int = i + j
def fun2(i:Int)(j:Int) : Int = i + j
println(fun1(2,3))
println(fun2(2){3})
println(fun2{2}{3} )
}
} // => 5 5 5

Functional Aspects: Currying (2)
Currying helps increase readability
Take foldleft as an example
Page 40
FoldLeft Operator
val x = (0 /: (1 to 10)) { (sum, elem) => sum + elem } // 55
Carryover value for next iteration
Function arguments
Carryover value
Collection
For each iteration, foldleft passes the carry over value and the current collection element. We need to provide the operation to be applied
This is collection which we iterate over
This is the value that is updated in each iteration
Think how this would be implemented in Java!

Positional Parameters
If you use a parameter only once, you can use positional notation of parameters with _ (underscore) instead
Page 41
val seq= (1 to 10)
println( (0 /: seq) { (sum, elem) => sum + elem } )
println( (0 /: seq) { _ + _ } )
}
}

Using the features we can build new DSLs and additional features easily
The following loop-unless example is from the Scala tutorial
Page 42
object TargetTest2 extends Application {
def loop(body: => Unit): LoopUnlessCond =
new LoopUnlessCond(body)
protected class LoopUnlessCond(body: => Unit) {
def unless(cond: => Boolean) {
body
if (!cond) unless(cond)
}
}
var i = 10
loop {
println("i = " + i)
i -= 1
} unless (i == 0)
}
We are calling loop
with this body ...
and invoking unless
on the result

Functional Aspect: Partially Applied Functions
If you only provide a subset of arguments to a function call, you actually retrieve a partially defined function
Only the passed arguments are bound, all others are not
In a call to a partially applied function you need to pass the unbound arguments
All this is useful to leverage the DRY principle when passing the same arguments again and again
Page 43
def fun(a : Int, b : Int, c:Int) = a+b+c
val partialFun = fun(1,2,_:Int)
println( partialFun(3) ) // 6
println( partialFun(4) ) // 7
}
}

Functions Are Objects
Function: S => T
 trait Function1[-S,+T] {
def apply(x:S):T
}
Example:
(x: Int) => x * 2
-> new Function1[Int,Int] {
def apply(X:Int):Int = x * 2
}
In Scala all function values are objects
Basically, each function is identical to a class with an apply method
Thus, you can even derive subclasses from functions
Array is an example for this:
class Array [T] (length: Int )
extends (Int => T) {
def length: Int = ...
Page 44

Functional Aspects: Pattern Matching
Pattern matching allows to make a pragmatic choice between various options
Page 45
valaNumber = new Random().nextInt(6) + 1;
aNumbermatch {
case 6 => println("You got a 6")
case 1 => println("You got a 1");
caseotherNumber => println("It is a " + otherNumber)
}

Functional Aspects: Matching on Types
It is also possible to differentiate by type:
Page 46
object TypeCase {
def matcher(a: Any) {
a match {
case i : Int if (i == 42) => println("42")
case j : Int => println("Another int")
case s : String => println(s)
case _ => println("Something else")
}
}
matcher(42)
matcher(1)
matcher("OOP")
matcher(1.3)
}
} // => 41 < > 1 < > OOP < > Something else

Functional Aspects: Matching on Lists
Lists can be easily used with Pattern Matching:
Page 47
object ListCase {
def matcher(l: List[Int]) {
l match {
case List(1,2,3,5,7) => println("Primes")
case List(_,_,_3,_) => println("3 on 3");
case 1::rest => println("List with starting 1");
case List(_*) => println("Other List");
}
}
matcher(List(1,2,3,5,7))
matcher(List(5,4,3,2))
matcher(List(1,4,5,6,7,8));
matcher(List(42))
}
} => Primes < > 3 on 3 < > List with starting 1 < > Other List

Functional Aspects: Matching on Tuples
So do Tuples:
Page 48
object TupleCase {
def matcher(t : Tuple2[String,String]) {
t match {
case ("OOP",s) => println("OOP " + s)
case ("Scala", s) => println("Scala " + s)
case _ => println("Other Tuple")
}
}
matcher("OOP", "2010")
matcher("Scala", "rocks");
matcher("A","B")
}
} => OOP 2010 < > Scala rocks >cr> Other Tuple

Functional Aspects: Matching on Case Classes
Case Classes are classes for which the compiler generates additional functionality to enable pattern matching, e.g., an apply() method:
Page 49
sealed abstract class Shape // sealed => subclasses only in this source file
case class Circle(val center: Point, val radius: Double) extends Shape
case class Line(val pt1: Point, val pt2: Point) extends Shape
case class Point (val x:Double, val y:Double){
override def toString() = "(" + x +"," + y + ")" }
object CaseClasses {
def matcher(s : Shape) {
s match {
case Circle(c, r) => println(“Circle“ : + c + “ “ + r)
case Line(p1, p2) => println("Line " + p1 + " : " + p2)
case _ => println("Unknown shape")
}
}
matcher(Circle(Point(1.0, 1.0), 2.0))
matcher(Line(Point(1.0, 1.0), Point(2.0, 2.0)))
}
}

Functional Aspect: Extractors
Extractors are objects with an unapply method used to match a value and partition it into constituents – an optional apply is used for synthesis
Page 50
object EMail {
def apply(prefix: String, domain: String) = prefix + "@" + domain
def unapply(s: String): Option[(String,String)] = {
val parts = s split "@"
if (parts.length == 2) Some(parts(0), parts(1)) else None
}
}
val s = "michael.stal@siemens.com"
s match {
case EMail(user, domain) => println(user + " AT " + domain)
case _ => println("Invalid e-mail")
}
}
}

Partial Functions
Partial Functions are not defined for all domain values
Can be asked with isDefinedAt whether a domain value is accepted
Example: Blocks of Pattern Matching Cases
Page 51
trait PartialFunction[-D, +T]
extends (D => T) {
def isDefinedAt(x: D): Boolean
}

Actors
Actors have been introduced in the 1970s:
the Actor model is a mathematical model of concurrent computationthat treats "actors" as the universal primitives of concurrent digital computation: in response to a message that it receives, an actor can make local decisions, create more actors, send more messages, and determine how to respond to the next message received. [Hewitt, 73]
Page 52
Also available in Erlang, Axum, Io, Clojure
Provided as library implementation in Scala (demonstrating Scala‘s capability of providing internal DSLs)

Actor Classes
Class Actor requires to override act() which is the functionality executed by a thread
You may also instantiate anonymous actors in a much more convenient way:
Page 53
import scala.actors.Actor
class VolcanextendsActor {
def act() {
println(“thinking ...")
}
}
object SpockRunner {
valspock = new Volcan
spock start
}
}
import scala.actors.Actor
import Actor._
object SpockRunner {
val spock = actor {
println("thinking ...")
}
}
}

Actors that communicate
An actor is useless unless it cooperates with other actors
Actors communicate via messages
In Scala‘s actor library messages are processed in FIFO order
Every actor owns an inbound and an outbound mailbox
Page 54

Communicating Actors - Example
Page 55
!
Note: react & receive have cousins with timeout arguments: receiveWithin and reactWithin
import scala.actors._
import Actor._
object Calculator extends Actor {
def fib(n: Int) : Int = { require(n >= 0) // this is a precondition
if (n <= 1) n else fib(n-2) + fib(n-1) }
def act() {
loop {
react { // or receive if thread must preserve call-stack
case i:Int => actor {println("Fibonacci of "+i+" is "+fib(i))}
case s:String if (s == „exit") => {println(„exit!"); exit}
case _ => println("received unknown message")
}
}
}
}
object ActorDemo extends Application {
Calculator.start // start Actor
for (i <- 0 to 30) Calculator ! i // here we send a msg to the actor
Calculator ! "exit"
}

Processing XML in Scala
Scala can directly handle XML
With package scala.xml we can read, parse, create and store XML documents
XPath like query syntax
Page 56
import scala.xml._ // in our example not required
object XMLDemo extends Application {
val x : scala.xml.Elem =
<conferences>
<conference name="OOP"> <year> 2010 </year> </conference>
<conference name="SET"> <year> 2010 </year> </conference>
</conferences>
var conferenceNodes = x "conference„ // get all conference nodes
for (c <- conferenceNodes) println( c"@name“ ) // get attribute
} // => OOP < > SET

Accessing the Web with Scala
You may use a mixture of Java and Scala code to access the Web
Suppose, you‘d like to read a Web Page
Here is an example how this might work
Page 57
import java.net._
object WebDemo {
require(args.length == 1)
// we assume an URL was passed at the
// command line:
val url = new URL(args(0)) // make URL
// read web page stream and convert
// result to a string:
val page =
io.Source.fromURL(url).mkString
println(page) // display result
}
}

Scala Installation & Use
Download distribution from http://www.scala-lang.org
You may use
Scala Compilers: scalac and fsc
Eclipse, JetBrains, NetBeans Plug-In
REPL (Read-Eval-Print-Loop) shell: scala
I have tested these on Windows {XP, Vista} as well as Mac OS X (Snow Leopard)
Or a Web site for evaluating Scala scripts: http://www.simplyscala.com/
If you are interested in a Web Framework based on Scala use Lift 1.0: http://liftweb.net/
Page 58

Summary
Scala combines the best of two worlds: OO and Functional Programming
It runs on the JVM and offers Java interoperability
Actor library helps dealing with complexity of concurrent programming
Scala programs are compact and concise => big productivity boost possible
Upcoming v2.8 will offer additional benefits such as named & default arguments
Scala is no island - many further tools and frameworks (e.g., Lift) available
Coding with Scala is fun - Try it yourself!
Page 59

Books: My Recommendations
M. Odersky, L. Spoon, B. Venners: Programming in Scala: A Comprehensive Step-by-step Guide (Paperback), Artima Inc; 1st edition (November 26, 2008) – The Language Reference!
V. Subramanian: Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (Pragmatic Programmers) (Paperback), Pragmatic Bookshelf (July 15, 2009)
D. Wempler, A. Paine: Programming Scala: Scalability = Functional Programming + Objects (Animal Guide) (Paperback), O'Reilly Media; 1st edition (September 25, 2009)
A lot of additional books available in the meantime.
Page 60

http://www.techgig.com	154
http://www.slideshare.net	13
http://www.linkedin.com	3

Oop2010 Scala Presentation Stal

by Michael Stal on Apr 09, 2010

Accessibility

Categories

Upload Details

Usage Rights

3 Embeds 170

Statistics

Oop2010 Scala Presentation Stal Presentation Transcript