An Introduction to Scala for Java Developers

An Introduction to Scala
for Java Developers

Miles Sabin, Chuusai Ltd.
http://www.chuusai.com/

http://uk.linkedin.com/in/milessabin
http://twitter.com/milessabin

Outline
●
Background
●
Cleaning up Java
●
Going Beyond Java
●
Lab 1
●
Functional Focus
●
Lab 2
●
Roadmap

Background
●
Designed by Martin Odersky (Pizza, GJ and
Java 5) of EPFL as the successor to Funnel
●
Objectives,
●
Blend object-oriented and functional styles
●
Seamless interoperability with Java (and .Net?)
●
Project started in 2003
●
First public release in 2004
●
Currently at 2.7.7
●
2.8 release due very soon

Why Mix OO and FP?
●
Each has complementary strengths —
●
OO provides excellent support for,
– Subtyping and inheritance
– Modular components
– Classes as partial abstractions
●
FP provides excellent support for,
– Higher order functions
– ADTs, structural recursion and pattern matching
– Parametric polymorphism
●
They've been converging for a while now

Scala is the Future of Java
●
Scala can be thought of as a superset of
current Java
●
It has all the object-oriented features of
current Java (some in a slightly different and
improved form)
●
It already has many of the most desirable
proposed extensions to Java (eg. true closures)
●
Nevertheless, it compiles to Java bytecode
●
Flawless interopability with Java, leverages the
mature Hotspot JIT

Interoperbility with Java
●
There are many alternative JVM languages.
Some are also strongly “Java-compatible”
●
Close source and binary mapping to Java
– Scala, Groovy, JavaFX, AspectJ
●
For these, prospect is that most Java tools,
libraries and frameworks will Just Work, or
work with only minor adaptation
●
Additional promise of gradual migration of
existing Java projects

Tools and Frameworks
●
Idiomatic testing frameworks —
●
Specs, ScalaTest, ScalaCheck
●
Idiomatic web frameworks —
●
Lift
●
Wicket and Play recently added Scala support
●
IDE support — the big three (Eclipse,
Netbeans, IDEA) all actively developed

Who's Using It?
●
A rapidly growing list of companies and
projects,
●
Twitter (infrastructure)
●
Foursquare (front-end, infrastructure)
●
LinkedIn (analytics, infrastructure)
●
EDF Trading (analytics, infrastructure)
●
Sony Pictures Imageworks (infrastructure)
●
SAP/Siemens (ESME, enterprise messaging)
●
Novell (Pulse, enterprise messaging)

Scala has a REPL
●
Common in scripting and functional
languages
●
Great for exploratory programming
●
We'll be using it as we go along

Resources

●
http://www.chuusai.com/spa2010
●
CDs and Memory Stick circulating
●
Let me know if you have difficulties

Scala Cleans Up Java Syntax
●
Semi-colons are optional
●
equals is ==, == is eq
●
Periods are optional where unambiguous,
scala> val s = "Hello world"
s: java.lang.String = Hello world

scala> s length
res8: Int = 11

●
Binary method invokations can be written
in operator form,
scala> s substring 6
res9: java.lang.String = world

Scala Cleans Up Java Syntax
●
All statements are expressions and have a
value,
val m = if (n % 2 == 0) n/2 else n*3+1

val pow4 = { val sqr = n*n ; sqr*sqr }

val n =
try { s toInt }
catch { case _ : NumberFormatException => 0 }

●
Method bodies are expressions and curly
braces are optional
def findSlash(s : String) : Int = s indexOf '/'

Statically Typed with Inference
●
Type inference eliminates the most
annoying explicit typing annotations
●
All definitions must have a static type
val m : Map[Int, String]

●
However these types are typically inferred
scala> val m = Map(1 -> "one", 2 -> "two")
m : Map[Int, String] = Map(1 -> one, 2 -> two)

●
Method return types are also inferred
scala> def twice(i : Int) = i*2
twice: (i: Int)Int

Vals, Vars and Uniform Access
●
Scala simplifies immutable definitions,
val s : String = "Hello immutable world"
s = "Bye ..." // Error
var t : String = "Hello mutable world"
t = "Bye ..." // OK

●
(Im)mutable properties can be
implemented by vals, vars or methods
class User {
val name : String // Immutable
var email : String // Mutable
def pass : String // Computed
def pass_=(s : String) //
}

user.pass = "<secret>" // Sugar for user.pass_=("<secret>")

Case Classes are Lightweight
●
Eliminate a lot of the boilerplate associated
with Java implementations of simple data
types
public class User {
private final String name;
private final String pass;
public User(String name_, String pass_) {
name = name_;
pass = pass_;
}
public String getName() { return name; }
public String getPass() { return pass; }
public boolean equals(Object other) { ... }
public int hashCode() { ... }
public String toString() { ... }
}

Case Classes are Lightweight
●
The Scala equivalent,
case class User(name : String, pass : String)

●
Accessors, toString and correct equals
and hashCode provided automatically
●
“new” omitted
val joe = User("Joe Bloggs", "<secret>")

●
“Copy with changes” supports immutable
functional objects
val joeUpdated = joe.copy(pass = "<still secret>")

No Statics
●
No static fields or methods
●
Instead "object” entities similar to singletons
// Java
public class User {
public static newUser(String name, String pass) {
return new User(name, pass);
}
// Non-static methods ...
}

// Scala
object User /* extends ((String, String) => User) */{
def apply(name : String, pass : String) =
new User(name, pass)
}
val joe = User("Joe Bloggs", "<secret>")

Scala is Object Oriented
●
Scala has a uniform object model: no
primitive types

Scala is Object Oriented
●
Operators aren't special, they're methods
like any other,
x + 1 // equivalent to x.+(1)

●
Classes can define methods which can
invoked in operator form,
case class Complex(val re : Double, val im : Double) {
def +(rhs : Complex) = Complex(re+rhs.re, im+rhs.im)
def *(rhs : Complex) =
Complex(re*rhs.re-im*rhs.im, im*rhs.re+re*rhs.im)
}
val c1 = Complex(1.0, 1.0) ; val c2 = Complex(2.0, 3.0)
c1+c2 // == Complex(3.0, 4.0)
c1*c2 // == Complex(-1.0, 5.0)

Named and Default Arguments
●
Arguments can be specified at call sites by
name
def coord(x : Double, y : Double)
coord(y = 1.0, x = 0.7)

Allows them to be provided naturally for
the call site, and eliminates ambiguity
●
Arguments can also be given default values
def printList(l : List[Int], sep : String =", ") { ... }

val l = List(1, 2, 3)
printList(l) // equivalent to printList(l, ", ")

Tuples
●
Scala has tuple types and literals
val coord : (Double, Double) = (1.0, 0.5)
println("x = "+coord._1+", y ="+coord._2)

●
These are first-class types like any other
val coords = new ListBuffer[(Double, Double)]
coords += coord

●
Provide ad hoc grouping and multiple
return values
def firstWord(s : String) = {
val i = s+" " indexOf ' '
(s.substring(0, i), s.substring(i, s.length))
}
val (first, rest) = firstWord("The quick brown fox ...")

Pattern Matching
●
Case classes model ADTs from functional
languages and support pattern matching
sealed trait Tree[T]
case class Leaf[T](elem: T) extends Tree[T]
case class Node[T](l: Tree[T], r: Tree[T]) extends Tree[T]

def find[T](tree : Tree[T], elem : T) : Boolean =
tree match {
case Node(l, r) => find(l, elem) || find(r, elem)
case Leaf(`elem`) => true
case _ => false
}

val t = Node(Node(Leaf("bar"), Leaf("baz")), Leaf("foo"))
find(t, "baz") // true

●
Matching is the inverse of construction

Mixin Composition
●
Java interfaces are replaced by traits and
mixin composition
●
Traits can provide method implementations
●
Traits can provide fields
trait UserId {
val name : String
var pass : String = "change me"
def display = name+":"+pass
}
class User(val name : String) extends UserId

val joe = new User("Joe Bloggs")
println(joe.display)

Mixin Composition
●
Traits support multiple inheritance whilst
avoiding the problems of “diamond”
inheritance
trait Email {
val address : String
def send(msg : String) {
println("Sending: "+msg) // Concrete implementation
}
}
class User(val name : String, val address : String)
extends UserId with Email

val joe = new User("Joe Bloggs", "joe@gmail.com")
println(joe.display)
joe.send("Don't forget to change your password!")

Laziness and By-Name Args
●
Values can be declared to be initialized
lazily
val (title, givenName, surname) = ("Mr.", "John", "Smith")
lazy val fullName = title+" "+givenName+" "+surname

The value is computed the first time it is
used (if at all)
val displayName = if (full) fullName else givenName

●
Create circular structures without update,
abstract class Link { val next : Link }
val (a : Link, b : Link) =
(new Link { lazy val next = b },
new Link { lazy val next = a })

Laziness and By-Name Args
●
Arguments can be passed by name
●
Similar to laziness in that evaluation is
deferred until use
●
Can be used to build specialized control
structures and enables internal DSLs
def locked[T](l : Lock)(op : => T) = {
l.lock
try { op } finally { l.unlock }
}
val lock = new ReentrantLock
var shared = ...
locked(lock) {
/* Use shared while holding lock */
}

Structural Typing
●
Scala has a form of statically checkable
duck-typing
●
We can use this to generalize libraries to
pre-existing types
type Closeable = { def close() }

def using[R <: Closeable, T](res : R)(op : R => T) =
try { op(res) } finally { res.close() }

val b = using(new FileInputStream("test.txt")) { _.read }

Implicit Conversions
●
Implicit functions provide a way to attach
new behaviours to exisiting types
●
Invoked if needed to typecheck
trait Closeable { def close : Unit }

def using[R <% Closeable, T](res : R)(op : R => T) =
try { op(res) } finally { res.close() }

implicit def InputStreamIsCloseable(is : InputStream) =
new Closeable { def close = in.close }

val b = using(new FileInputStream("test.txt")) { _.read }

●
Provides Haskell-like ad hoc polymorphism

The Scala IDE for
Eclipse

Main Features
●
Extends the JDT to support mixed
Scala/Java projects
●
Semantically aware editor
●
Project and source navigation
●
Incremental builder
●
Integrated debugger
●
Free, open source ...

Participate!
●
The Scala IDE for Eclipse's home
http://www.scala-ide.org/
●
Wiki, git repository, bugs
http://scala-ide.assembla.com/
●
Mailing lists
http://groups.google.com/group/scala-ide-user
http://groups.google.com/group/scala-ide-dev
●
Follow @ScalaIDE on Twitter

First-Class Functions
●
Scala allows the definition of functions
def plusOne(x : Int) = x+1

●
Functions can be arguments and results
def applyTwice(x : Int, f : Int => Int) = f(f(x))
applyTwice(3, plusOne) // == 5

●
Can be anonymous and close over their
environment
def twice(f : Int => Int) = (x : Int) => f(f(x))
twice(plusOne)(3) // == 5

●
Function literal syntax is concise
twice(_+1)(3) // == 5

Higher-Order Functions
●
Higher-order functions are used
extensively in Scala's standard library
List(1, 2, 3).map(_*2) // == List(2, 4, 6)

List(1, 2, 3, 4).find(_%2 == 0) // Some(2)

List(1, 2, 3, 4).filter(_%2 == 0) // List(2, 4)

def recip(x : Int) = if(x == 0) None else Some(1.0/x)

scala> List(0, 1, 2, 3).flatMap(recip)
res0: List[Int] = List(1.0, 0.5, 0.3333333333333333)

The Option Type
●
“Null References: The Billion Dollar
Mistake” — Tony Hoare
●
Scala provides a safe alternative
scala> List(1, 2, 3) find (_ == 2)
res0: Option[Int] = Some(2)

scala> List(1, 2, 3) find (_ == 4)
res0: Option[Int] = None

●
Option interacts nicely with matching
List(1, 2, 3) find (_ == 2) match {
case Some(i) => println("Found "+i)
case None => println("Not found")
}

For Comprehensions
●
Scala's “for comprehensions” capture
common patterns of use of map, flatMap
and filter
val l1 = List(0, 1)
val l2 = List(2, 3)

scala> for (x <- l1; y <- l2) yield (x, y)
res0: List[(Int, Int)] = List((0,2), (0,3), (1,2), (1,3))

The for expression desugars to,
l.flatMap(x => l2.map(y => (x, y))

●
These patterns are the monad laws for the
subject type

For Comprehensions
●
Option implements map, flatMap and Filter
so works nicely with for comprehensions
def goodPair(x : Int, y : Int) =
for(fst <- recip(x); snd <- recip(y))
yield (x, y)

scala> goodPair(1, 2)
res0: Option[(Int, Int)] = Some((1,2))

scala> goodPair(1, 0)
res0: Option[(Int, Int)] = None

●
Using Option rather than null has clear
benefits when used in this way

Roadmap
●
Upcoming releases,
●
Release Candidate 2 of 2.8 now available
●
2.8 Final expected July/August
●
Subsequent 2.8-series releases will
continue current exploratory work,
●
Type specialization (still needs library support)
●
Continuations (currently a compiler plugin)
●
Linear/immutable/non-null types

Find Out More
●
Scala's home at EPFL
http://www.scala-lang.org
●
See also the scala and scala-user mailing list
●
The London Scala Users' Group
http://www.meetup.com/london-scala
●
Publications
●
Programming in Scala
Odersky, Venners and Spoon
●
Programming in Scala
Wampler and Payne

An Introduction to Scala for Java Developers

More Related Content

What's hot (17)

Viewers also liked (6)

Similar to An Introduction to Scala for Java Developers (20)

More from Miles Sabin (6)

Recently uploaded (20)

An Introduction to Scala for Java Developers