Stepping Up : A Brief Intro to Scala

Stepping Up: A Brief Intro to Scala

Derek Chen-Becker, October 10th, 2009

A little background

Scala began around 2003, 2.0 in 2006,
currently at 2.7.5 (stable)

Created by Martin Odersky (EPFL), of GJ,
and later Javac v5 fame

Compiles to 100% Java Bytecode

Generally works flawlessly with Java

Leverages JIT: performance ±5% of Java

Excellent community (mailing lists, IRC)

In use at Twitter, Seimens, Xerox, and others

Not quite déjà vu...
Scala combines features from many different
languages to form a unique hybrid:

Scala is pure OO. Everything is an object, even
primitives

Scala has first-class function objects. Much of
the library leverages function arguments

Scala has a comprehensive type system and a
flexible inheritance mechanism

Method names have less restrictions. This allows
for operator overloading and nice DSLs

Immutability is strongly supported and
encouraged. This is important for multi-core

Statics and Singletons


Scala makes a distinction between
instance and static methods and fields by
using a separate “object” entity to
represent the latter

Objects are VM singletons

Objects can be used to create custom
factories and pattern matching extractors
(more in a moment)

Scala is Succinct
public class Bike {
private String brand;
private int gear;

public Bike(String brand, class Bike (val brand : String,
int gear) { var gear : Int) {
this.brand = brand; override def toString =
this.gear = gear; "This is a %s in gear %d"
} .format(brand, gear)
}
public int getGear() {
return gear;
}

public void setGear(int gear) {
this.gear = gear;
}

public String getBrand() {
return brand;
}
public String toString() {
return String.format("This is a %s in gear %d", brand, gear);
}
}

Scala has Case Classes

Case classes are defined basically like normal
classes

By default are immutable (good!)

Constructor parameters are automatically vals

Automatically get a companion object with
apply/unapply, as well as overrides for equals,
hashCode and toString on the class itself

case class Book(title : String, author : String)

val classic =
Book("A Tale of Two Cities", "Dickens")

val Book(title,author) = classic

Scala has Case Classes, part 2

Can inherit from other classes (although inheriting
from other case classes is being deprecated)

Can have their own methods just like normal
classes

class Vehicle(val description : String,
val topSpeed : Long)

case class Airplane(description : String,
topSpeed : Long,
var fuel : Double)
extends Vehicle(description,speed) {
def takeOff {...}
}

Scala is Functional
Functions in Scala are first-class objects, and
can be passed as arguments, assigned to
variables, etc.

val printLog =
{ msg : String => // or ⇒
println(System.currentTimeMillis + ":" + msg)
}

List("one", "two", "three").foreach(printLog)

Scala is Functional, Part 2
Functions (and Scala's type system) allow you
to do things like define new control structures
in a type-safe way:
// Structural typing allows any type with a “close” method
def using[A <: { def close() : Unit }, B]
(resource : A )
(f : A => B) : B =
try {
f(resource)
} finally {
resource.close
}

val firstLine =
using(new BufferedReader(new FileReader("/etc/hosts"))) {
reader => reader.readLine
}

Scala has Closures
Closures capture variables in the scope of their
definition. These are ideal for callbacks, among
other things.

// Note that this example is not thread-safe
def logAndAdd(name : String) = {
var counter = 0

val logFunc = { msg : String =>
println(name + "-" + counter + ":" + msg)
counter += 1
}

logFunc
}

Scala is Higher Level
In particular, collections support complex
operations directly:
case class User(name : String, age : Int)
val people = List(User("Fred", 35), User("Barney", 32),...)

val sorted = people.sort(_.age < _.age).take(5)

// The same as :
val sorted =
people.sort({(a,b) => a.age < b.age}).take(5)

val under30 = sorted.takeWhile(_.age < 30)

val youngest5 = sorted.take(5)

val oldest5 = sorted.takeRight(5).reverse

Scala has For-Comprehensions
For-comprehensions provide an elegant
construct for tying multiple sources and
criteria together to extract information:
val prefixes = List("/tmp", "/work",
System.getProperty("user.home"))

val suffixes = List("txt", "xml", "html")

def locateFiles(name : String) : List[String] =
for (prefix <- prefixes;
suffix <- suffixes;
filename <-
Some("%s/%s.%s".format(prefix, name, suffix))
if (new File(filename)).exists)
yield filename

Scala does Pattern Matching

Like the “switch” statement on steroids

Incredibly powerful for expressing
conditional logic

Cases are tested in order
def matchIt (in : Any) = in match {
case 1 | 14 | "test" => {...}
case x : Int => {...}
case x : Double if x > 42.0 => {...}
case Vehicle(description, _) => {...}
case <head>{ stuff }</head> => {...}
case _ => {...}
}

Scala does Custom Matching

My favorite Scala example (more in the
handout)
// Regexps in Scala define a custom unapply to match on groups
val colonSplit = """(w+):(w+)""".r

// It's easy to define your own as well
object IntVal {
def unapply(in : String) =
try { Some(in.toInt) } catch { case _ => None }
}

def parts (in : String) = in match {
// Matching allows nested use of extractors (here we want Ints)
case colonSplit(IntVal(number), value) if number == 14 => {...}
case colonSplit(IntVal(number), value) => {...}
case colonSplit(key, value) => {...}
case _ => {...}
}

Scala has Traits

At their most basic, traits are 1-to-1 with Java
interfaces

Support concrete implementations of methods

Support both concrete and abstract
implementations of vals and vars

trait Named {
val version = "1.0.0"

val name : String

def printName { println(name) }
}

Scala Enforces Trait Composition

Traits can restrict which classes and traits
they can be mixed into

Traits can also define what “this” means
trait CreepyPerson extends Named {
self : Person =>

override def printName {
println("Creepy! " + name +
", size = " + this._size)
}
}

class A extends CreepyPerson {} // Error!

Scala Mixes In Traits

Classes can have multiple traits mixed in,
but can still only extend one superclass

Disambiguation of method calls is done via
a process called “Linearization”. Basically,
right-to-left
trait Messageable { def msg (msg : String) }

trait Emailable extends Messageable {...}

trait SMSable extends Messageable {...}

class iPhone extends SMSable
with Emailable {...}

Scala has Native XML

XML literals are part of Scala's syntax

Xpath-like expressions and pattern
matching supported for extraction
val simpleFragment =
<entries>
<entry><name>Fred</name></entry>
<entry><name>Barney</name></entry>
</entries>

(simpleFragment "name").toList.map(_.text)

simpleFragment.child.foreach({
case <entry><name>{name}</name></entry> => println(name);
case _ =>
})

Scala has Native XML, Part 2

Values can be embedded in XML literals
via braces.

Interpretation of values is via toString,
although scala.xml.{PCData,Unparsed} can
do special handling
// <name>Fred&Barney</name>
val embedFragment =
<name>{ "Fred&Barney" }</name>

val noEscapes = // <name>Betty&Wilma</name>
<name>{ Unparsed("Betty&Wilma") }</name>

Conclusion


Scala lets you write less boilerplate and
concentrate on the logic

Interoperates very well with the existing
Java ecosystem

IDE support is still not where it needs to be,
but it's functional

Odersky, et. al, are committed to long-term
growth and stability

Further Reading


http://www.scala-lang.org/

http://scala.sygneca.com/

Books:

Programming in Scala by Odersky, Venners &
Spoon

Beginning Scala by David Pollak

Programming Scala by Wampler & Payne (online)

Programming Scala by Venkat Subramaniam

Steps in Scala by Loverdos & Syropolous

The Definitive Guide to Lift (shameless plug)

Stepping Up : A Brief Intro to Scala

More Related Content

What's hot

Similar to Stepping Up : A Brief Intro to Scala

Recently uploaded

Stepping Up : A Brief Intro to Scala