• Save
Oop2010 Scala Presentation Stal
Upcoming SlideShare
Loading in...5
×
 

Oop2010 Scala Presentation Stal

on

  • 6,440 views

This presentation offers a tutorial for introducing Scala. Readers should be familiar with C++, C# or Java

This presentation offers a tutorial for introducing Scala. Readers should be familiar with C++, C# or Java

Statistics

Views

Total Views
6,440
Views on SlideShare
6,254
Embed Views
186

Actions

Likes
20
Downloads
0
Comments
0

5 Embeds 186

http://www.techgig.com 164
http://www.slideshare.net 13
http://www.linkedin.com 7
http://www.slashdocs.com 1
http://dschool.co 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Oop2010 Scala Presentation Stal Oop2010 Scala Presentation Stal Presentation Transcript

  • 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
    def main(args: Array[String]) {
    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 {
    def main(args:Array[String]) = {
    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 {
    def main(args:Array[String]) {
    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 {
    def main(args:Array[String]) {
    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
    }
    }
    def main(args:Array[String]) {
    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 {
    def main(args:Array[String]) {
    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 {
    def main(args: Array[String]) {
    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 {
    def main(args: Array[String]) {
    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
    }
    def main(args: Array[String]) {
    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)
    def main(args:Array[String]) {
    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
    object scalafunctions {
    def fun1(i:Int, j:Int) : Int = i + j
    def fun2(i:Int)(j:Int) : Int = i + j
    def main(args: Array[String]) {
    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
    object scalafunctions {
    def main(args:Array[String]) {
    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
    object scalafunctions {
    def fun(a : Int, b : Int, c:Int) = a+b+c
    def main(args: Array[String]) {
    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")
    }
    }
    def main(args: Array[String]) {
    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");
    }
    }
    def main(args: Array[String]) {
    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")
    }
    }
    def main(args: Array[String]) {
    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")
    }
    }
    def main(args: Array[String]) {
    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
    }
    }
    object scalafunctions {
    def main(args:Array[String]) {
    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 {
    def main(args:Array[String]) = {
    valspock = new Volcan
    spock start
    }
    }
    import scala.actors.Actor
    import Actor._
    object SpockRunner {
    def main(args:Array[String]) = {
    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 {
    def main(args: Array[String]) {
    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