Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Introduction to Scala
The “new” Java?
Eivind Barstad Waaler
BEKK/UiO
July 4, 2009
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Presentation Outline
Outline
Introduction
Concise Syntax
Object Orientation
Functional Programming
Various Stuff
Conclusion
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Introducing Scala
What is Scala?
I 100% Object-oriented
I Functional programming
I Typing: static, strong, inferred/implicits
I Java bytecode → JVM
I .NET (CLR) Also available
I Extensibility
I Java-like syntax → Scala syntax
I Current version 2.7.5 → 2.8
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Introducing Scala
A first example
class IntMath(val x: Int, val y: Int) {
def sum(): Int = {
x + y;
}
def mul = x * y
}
val test = new IntMath(3, 4)
println(test.x) // output: 3
println(test.sum) // output: 7
println(test.mul()) // output: 12
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Introducing Scala
The Scala Interpreter
I An interactive “shell” for writing Scala expressions
I Automatically creates temporary result variables
I Simply type ’scala’ at the command prompt
I Using Maven2:
I Type ’mvn scala:console’
I Starts the Scala Interpreter with project classpath
I Demo ⇒
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Syntax Examples
Imports
I Like Java, but more features
I Can be anywhere
I Import from packages, classes or objects
import java.util._ // All
import java.util.{ArrayList,HashSet} // Selected
import java.util.{ArrayList => _, _} // All except
import java.util.ArrayList._ // All from AL
val list = new ArrayList
import list._ // All from object list
import java.sql.{Date => SDate} // Renaming
import java.util.Date
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Syntax Examples
Method syntax
I . and () can be omitted for binary/unary methods
I Methods can have any name
I Operators are simply methods → full operator overloading
2.max(5) // max of 2 and 5
2 max 5 // same as above
class MyNumber(val num: Int) {
def +(other: MyNumber) = new MyNumber(other.num + num)
}
val x = new MyNumber(5)
val y = new MyNumber(6)
val z = x + y
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Syntax Examples
Type inferrence/implicits
I If type is obvious – no need to write it
I Implicits can be defined
I Implicits heavily used in std lib (RichInt etc.)
// Type inferrence
val a = 42 // Type = Int
val b = "hello world!" // Type = String
def add(x: Int, y: Int) = x + y // Return-type = Int
val sum = add(3, 5) // Type of sum = Int
// Implicits
class MyInt(val i: Int) { def doubleIt = i * 2 }
implicit def fromInt(i: Int) = new MyInt(i)
5.doubleIt // = 10
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
OO Introduction
Object Orientation
I Pure OO – everything is an object
I Classes – blueprints for objects (like Java)
I Singleton objects
I Traits – AOP like possibilities
I Semicolon inference
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Classes and Objects
Scala Class Hierarchy
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Classes and Objects
Classes
I Much like Java
I Contains fields and methods – can override eachother
I override keyword mandatory
I Can take parameters directly – constructor
class A(val num: Int)
class B(num: Int, val str: String) extends A(num) {
def calc() = num * num // calc is a method
}
class C(num: Int, str: String) extends B(num, str) {
override val calc = 65 // override method with val
}
val a = new A(35) // Type A
val b = new B(32, "Eivind") // Type B - calc method
val b2: B = new C(32, "Eivind") // Also type B - calc val
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Classes and Objects
Singleton Objects
I No static members in Scala → Singleton Objects
I Keyword object instead of class
I Companion class/object – same name
I Factory methods
I Other unique/static behaviour
// Array class definition
final class Array[A](_length: Int) extends Array0[A]
// Array object definition with method
object Array {
def apply(xs: Int*): Array[Int] = { ... }
}
// Create array with four integers
val arr = Array(1, 2, 3, 4)
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Classes and Objects
The “magic” apply()-method
I Scala provides special syntax for calling the apply() method
I In classes used to look up elements (for instance in
Collections)
I In objects used to create class instances
I Functions in Scala are actually just apply() methods
I Make your classes/objects appear as built-in syntax
// Array object has apply method for creating arrays
def apply(xs: Int*): Array[Int] = { ... }
// Array class has apply method to access the array
def apply(i: Int): A
// Scala special syntax
val arr = Array(4, 3, 2, 1) // Array.apply(4, 3, 2, 1)
val three = arr(1) // arr.apply(1)
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Traits
Traits
I Encapsulates method and field definitions, much like classes
I A class can mix in any number of traits → multiple inheritance
I Widen thin interfaces to rich ones
I Define stackable modifications
trait Hello {
def hello { println("Hello!") }
}
trait Goodbye {
def bye { println("Bye bye!") }
}
// Object with both hello() and bye() methods..
object A extends Hello with Goodbye
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Traits
Traits – Widen thin interface to rich
I Define one or a few abstract methods
I Define concrete methods implemented in terms of the abstract
trait Ordered[A] {
abstract def compare(that: A): Int
def <(that: A): Boolean = this.compare(that) < 0
def <=(that: A): Boolean = this.compare(that) <= 0
...
}
class Name(val name: String) extends Ordered[Name] {
def compare(that: Name) = this.name.compare(that.name)
}
if(name1 <= name2) { ... // val name1 = new Name("Ola")
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Traits
Traits – Define stackable modifications
I Modify methods of a class
I Stack several modifications with each other
abstract class IntQueue {
def get: Int
def put(x: Int)
} // + concrete impl IntQueueImpl
trait PutPrint extends IntQueue {
abstract override def put(x: Int) {
println("Put: " + x)
super.put(x)
}
}
val printQueue = new IntQueueImpl with PutPrint
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Generics and Abstract Types
Generics
I Classes and traits can be generified
I Generics/type parameterization impl with erasure (like Java)
I Type parameters are required (not like Java)
I Variance – nonvariant, covariant and contravariant
I Upper and lower bounds
trait Set[T] { // Nonvariant
def contains(elem: T): Boolean
...
trait Set[+T] // Covariant
trait Set[-T] // Contravariant
trait OrderedSet[T <: Ordered[T]] // Upper bound
trait Array[+T] {
def indexOf[S >: T](elem: S): S // Lower bound
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Generics and Abstract Types
Abstract types
I Types as abstract members
I Much like type parameterization, different usage
I Generic types – reusable containers, collections ++
I Abstract types – premade subclasses, hides implementation
abstract class OrderedSet {
type DType <: Ordered[DType]
...
class IntSet extends OrderedSet {
type DType = RichInt
...
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Introduction to Functional Programming
Functional programming
I Scala goal: Mix OO and FP
I Some FP characteristics:
I Higher-order functions
I Function closure support
I Recursion as flow control
I Pure functions – no side-effects
I Pattern matching
I Type inferrence/implicits
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Introduction to Functional Programming
Mutable/immutable
I Immutable data structures important in FP
I Pure function – same result with same arguments
I Scala uses keywords var and val
I Immutable definitions (val) encouraged
val num = 45 // Immutable - allways 45
num = 60 // Error: reassignment to val
var num2 = 45 // Mutable - can be changed
num2 = 60 // Ok
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Functions
Scala functions
I Higher-order functions – args and results
I Objects that implement scala.FunctionN traits
I Special syntax support with => operator
// Three equivalent definitions to find even numbers
val f1 = new Function[Int, Boolean] { // Full version
def apply(i: Int) = i % 2 == 0
}
val f2 = (i: Int) => i % 2 == 0 // Special operator
def f3(i: Int) = i % 2 == 0 // Regular function definition
// Usage (f1, f2 and f3 equivalent)
f1(64) // Converts to f1.apply(64)
val arr = Array(1, 2, 3, 4)
arr.filter(f1) // Returns Array(2, 4)
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Functions
Closures/anonymous functions
I Scala – Anonymous functions
I Like anonymous classes in Java (and Scala)
I Nothing special with closures – just passing function object
I The (underscore) can be used to anonymize arguments
val arr = Array(1, 2, 3, 4)
arr.filter((i: Int) => i % 2 == 0) // Returns Array(2, 4)
arr.filter(_ % 2 == 0) // Shorter version using _
arr.map(_ % 2) // Returns Array(1, 0, 1, 0)
arr.foreach(print _) // Prints "1234"
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Functions
Partially applied functions and currying
I Partially applied functions – leave args out
I Currying – multiple argument lists
// Partially applied function
def sum(i: Int, j: Int) = i + j
val fivePlus = sum(5, _: Int) // New func with 1 arg
fivePlus(6) // Result 11
val myprint = print _ // Example from previous slide
myprint("hello world!")
// Currying example
def curriedSum(i: Int)(j: Int) = i + j
curriedSum(2)(3) // Result 5
val fivePlus = curriedSum(5)_ // New func with 1 arg
fivePlus(6) // Result 11
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Pattern Matching
Pattern matching
I Like switch statements on steroids
I Kinds of patterns:
I Wildcard patterns – the char again
I Constant patterns – numbers, strings ++
I Variable patterns – names
I Constructor patterns – case classes
I Sequence patterns – all sequence classes (List, Array ++)
I Tuple patterns – all tuples
I Typed patterns – like function arguments
I Variable binding – using the @ sign
I Pattern guards – adding an if clause
I Pattern overlaps – case order is important!
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Pattern Matching
Pattern matching – Basic example
def desc(x: Any) = x match {
case 5 => "five" // Constant pattern
case i: Int => "int: " + i.toString // Typed patterns
case s: String => "str: " + s
case (a, b) => "tuple: " + a + b // Tuple pattern
case _ => "unknown" // Wildcard/default pattern
}
desc(8) // "int: 8"
desc("Scala") // "str: Scala"
desc(5) // "five"
desc(("Eivind", 32)) // "tuple: Eivind32"
desc(4.0) // "unknown"
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Pattern Matching
Pattern matching – Case classes example
I Factory method + all params are val
I Methods toString, hashCode and equals added
case class Person(name: String, age: Int)
def greet(x: Any) = x match {
case Person("Eivind", 32) => "Hello creator!"
case Person(n, a) if a < 32 => "Hello young " + n
case Person(n, _) => "Hello " + n
case _ => "Hello whatever"
}
greet(Person("Ola", 80)) // Hello Ola
greet(Person("Ola", 5)) // Hello young Ola
greet("Eivind") // Hello whatever
greet(Person("Eivind", 32)) // Hello creator!
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Pattern Matching
Pattern matching – List example
def desc(x: Any) = x match {
case List(_: String, _: String) => "List of two strings"
case List(_, _) => "List of two elems"
case head :: _ => "List starting with " + head
case _ => "Whatever"
}
desc(List(1, 2)) // List of two elems
desc(List(1, 2, 3)) // List starting with 1
desc(List("hello", "world")) // List of two strings
// Note! Two equivalent defs - "Error: unreachable code"
case head :: _ => "List starts with " + head
case List(head, _*) => "List starts with " + head
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Other Functional Concepts
For expressions
I Generators, definitions and filters
I Can yield value – Range class
I A rewrite of methods map, flatMap and filter
for (l <- "letters") println(l) // Split with line
for (num <- 1 until 10) print(num) // Prints "123456789"
for {
p <- persons // Generator
n = p.name // Definition
if(n startsWith "E") // Filter
} yield n
// Two generators - with ( and ; to compact
for (n <- 1 to 3; l <- "xyz") yield n.toString + l
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Interesting Tidbits
Actors api
I Simplify concurrent programming
I Hides threads – message based
I Immutable objects and functional style recommended!
import scala.actors.Actor._
val helloActor = actor {
while (true) {
receive {
case msg => println("hello message: " + msg)
}
}
}
helloActor ! "Hello World!!"
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Interesting Tidbits
Continuations
I Coming in Scala 2.8
I Typical tasks:
I Asynchronous I/O with Java NIO
I Executors and thread pools
I Cross-request control flow in web applications
I New library functions, not keywords – shift and reset
I Complicated – different mindset
reset {
shift { k: (Int => Int) =>
k(k(k(7)))
} + 1
} * 2 // result: 20
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Interesting Tidbits
Java integration
I Java is called from Scala directly
I @scala.reflect.BeanProperty annotation
import java.util.Date
val d = new Date
I Scala compiles to standard Java bytecode
I Singleton objects – combo of static and instance methods
I Traits – interface + ancillary class
I Operators – methods with special names
def +(other: RichInt) = ... // Scala
public RichInt \$plus(RichInt other) { ... } // Java
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
Outline Introduction Concise Syntax Object Orientation Functional Programming Various Stuff Conclusion
Rounding It Up
Conclusion
I Object orientation and functional programming combined
I Static and compiled – benefits, not obstacles
I Rich syntax – Java-code / 3?
I Seamless integration with Java – run in existing environment
I Big momentum – the ”new” Java?
More Info:
http://www.scala-lang.org/
Eivind Barstad Waaler BEKK/UiO
Introduction to Scala
