What is Scala ?

"Java + ML + Extra Magic"

Created by Martin Odersky @ EPFL

Widely used (Twitter, FourSquare, LinkedIn, ...)

Why Scala?

Why Scala? Multi Paradigm

Functional Programming

+ Object-Oriented Programming

+ Imperative Programming

= "Post-Functional Programming"

Interesting blend. Many exciting new features.

Why Scala? Bleeding Edge

Modern type system (subclassing, generics, implicits, ...)

Modern concurrency (actors, collections, ...)

Seamless integration with Java

Why Scala?

Because I wanted to learn how it works!

Because it will teach you to learn new PLs!

Plan: Rest of the Quarter

Whirlwind Overview + Advanced Features

"Crash course": Expressions, Values, and Types

Classes, Subtyping, and Generic Polymorphism

Inheritance, Traits, and Mixins

Implicits and Type-Classes

Many Resources

Online (These are highly recommended!)

Martin Odersky's First Steps in Scala
Note: Interpreter output differs from current version of Scala.
Twitter's Scala School
Matt Might's Scala In Small Bites
API Search Engine scalex.org

Many Resources

Books

Programming in Scala, by Odersky, Spoon & Venners
Scala for the Impatient, by Horstmann

Let's Start the "Crash Course"!

Scala 101: Expressions & Types

Like ML, Scala is statically typed

(Almost) everything is an expression, which has a type

Type system is rather different than ML's...

Scala 101: Read-Eval-Print Loop

The easiest way to get started is with Scala's REPL

$ scala
Welcome to Scala version 2.10.3 ...
Type in expressions to have them evaluated.
Type :help for more information.

scala>

Scala 101: Read-Eval-Print Loop

Enter expressions and have them evaluated.

scala> 2
res0: Int = 2

scala> 2 + 3
res1: Int = 5

Everything is an "Object"

So when you type:

2 + 3

the compiler sees the method call:

2.+(3)

So + is just a method call! (As are many other things...)

Everything is an "Object": Overloading

Furthermore, unlike ML (and like Java) Scala supports "overloading".

scala> 2 + "cat"
res3: String = 2cat

scala> 2 + 3.0 
res4: Double = 5.0

Each of these calls the appropriate method on the receiver Int.

Everything is an "Object": Overloading

But don't get carried away...

scala> 2 + true

<console>:8: error: overloaded method value + with alternatives:
  (x: Double)Double <and>
  (x: Float)Float <and>
  (x: Long)Long <and>
  (x: Int)Int <and>
  (x: Char)Int <and>
  (x: Short)Int <and>
  (x: Byte)Int <and>
  (x: String)String
 cannot be applied to (Boolean)
       2 + true
         ^

Basic Data

You have your basic built-in types...

scala> 4.2 * 6.7
res8: Double = 28.14

scala> true || false
res9: Boolean = true

scala> 'c'
res10: Char = c

Basic Data

Strings are borrowed from Java...

scala> "cat"
res25: java.lang.String = cat

scala> "cat" + "dog"
res26: java.lang.String = catdog

scala> "cat" * 3 
res26: java.lang.String = catcatcat

Basic Data

... and you can take whatever you like from Java.

scala> import java.util.Date
import java.util.Date

scala> new Date()
res2: java.util.Date = Thu Nov 08 17:40:50 PST 2012

So every Java library is usable in Scala!

Result Variables

Notice that the REPL gives names to resulting values.

scala> "Cool!"
res2: String = Cool!

scala> res2
res3: String = Cool!

Speaking of Variables...

Variables

Two ways to introduce variables:

Immutable (a.k.a. The "right" way)

Mutable (a.k.a. The "if-you-must" way)

Immutable Variables

With the val keyword:

scala> val x = 2
x: Int = 2

val x = e is like OCaml's let x = e
So don't try to change (re-assign) such a variable!

scala> x = x + 1
<console>:8: error: reassignment to val
       x = x + 1
         ^

If you absolutely must: Mutable Variables

scala> var z = 1 
z: Int = 1

scala> z += 1

scala> z
res1: Int = 2

scala> z = 3
z: Int = 3

We will revisit val and var when we talk about objects and fields.

Compound Data: Tuples

Scala comes equipped with modern amenities like tuples.

scala> val t = ("cat", 12)
t: (java.lang.String, Int) = (cat,12)

scala> val t2 = ("mickey", 12, "mouse")
t2: (java.lang.String, Int, java.lang.String) 
    = (mickey,12,mouse)

scala> val t3 = ("mickey", (12, "mouse"))
t3: (java.lang.String, (Int, java.lang.String)) 
    = (mickey,(12,mouse))

Tuple types are written (T1, T2) and (T1, T2, T3) and so on
(unlike (T1 * T2) as in OCaml).

Compound Data: Tuples

To access the tuple elements, you can use pattern matching

scala> t
res7: (java.lang.String, Int) = (cat,12)

scala> val (p, q) = t
p: java.lang.String = cat
q: Int = 12

or the tuple field accessors ._1 or ._2, etc.

scala> t._1
res5: java.lang.String = cat

scala> t._2
res6: Int = 12

Compound Expressions

You can sequence expressions to get bigger expressions:

scala> :paste
// Entering paste mode (ctrl-D to finish)

{ println("hello world")
  2 + 8 }

// Exiting paste mode, now interpreting.

hello world
res0: Int = 10

Paste-mode lets you enter multi-line expressions in REPL.

Compound Expressions

A sequence of expressions in {...} is called a block.

Semi-colons between expressions in a block is often optional.

Functions

Many ways to define functions. One way:

def inc(x: Int): Int = {
  x + 1
}

Notice explicit argument and return types...

Call a function in the usual way (parentheses required):

scala> inc(4)
res3: Int = 5

Functions

No explicit return, just a result expression (like ML):

def adder(x: Int, y: Int): Int = {
  println("adder args: (x=%d, y=%d)".format(x, y))
  val z = x + y
  println("adder ret: (z=%d)".format(z))
  z
}

Block evaluates to last expression

scala> adder(2, 3)
adder args: (x=2, y=3)
adder ret: (z=5)
res6: Int = 5

Curried Functions

def curriedAdder(x: Int)(y: Int): Int = {
  println("curriedAdder args: %d %d".format(x, y))
  x + y 
}

Curried functions require parens around each argument!

scala> curriedAdder(2)(3)
curriedAdder args: 2 3
res7: Int = 5

Curried Functions

What about partial application as in OCaml?

scala> curriedAdder(2)(3)
curriedAdder args: 2 3
res7: Int = 5

scala> val add2 = curriedAdder(2)
error: missing arguments for method curriedAdder ...

Curried Functions

To partially apply, need _ for all other arguments:

scala> val plus2 = curriedAdder(2)(_)
plus2: Int => Int = <function1>

scala> plus2(3)
curriedAdder args: 2 3
res8: Int = 5

Curried Functions

You can partially apply any of the arguments...

scala> val plus3 = curriedAdder(_:Int)(3)
plus3: Int => Int = <function1>

scala> plus3(2)
curriedAdder args: 2 3
res9: Int = 5

Whoa!

Note: sometimes Scala will complain and ask for a type annotation.

Functions with No Name

A.k.a anonymous functions, like OCaml's fun x -> e

scala> (x: Int) => x + 1 
res3: (Int) => Int = <function1>

scala> (x: Int, y: Int) => x + y 
res2: (Int, Int) => Int = <function2>

Notice the types of the functions

Functions with No Name

Can call directly:

scala> ((x: Int) => x + 1)(8)
res3: Int = 9

Usually makes sense to bind to a name first:

scala> val inc = (x: Int) => x + 1
inc: (Int) => Int = <function1>

scala> inc(5)
res5: Int = 6

Functions are Objects, Too!

Functions are just objects with apply method.

scala> object inc { def apply(x: Int) = x + 1 }

Call them like so:

scala> inc(5)
res: Int = 6

Functions are Objects, Too!

Functions are just objects with apply method.

When you write f(args) Scala reads f.apply(args)

Enables many fun features

"Uniform Access Principle"

Functions are Objects, Too!

Anything with apply can be called.

scala> val str = "megalomaniac"
str: String = megalomaniac

scala> str(2)
res: Char = g

So far: Basic Data, Variables, Functions

Next: Control Expressions

Control Expressions

The usual suspects ...

if-else
try-catch
while-loops
for-loops

Control Expressions: If-Else

def fac(n: Int): Int = {
  if (n > 0) { n * fac (n-1) } else { 1 }
}

The {...} around then and else expressions can sometimes be omitted.

def fac(n: Int): Int = {
  if (n > 0) n * fac (n-1) else 1
}

But, it's okay to always write {...}.

Control Expressions: Pattern Matching!

Scala has pattern matching, too:

def fac(n: Int): Int =
  n match {
    case n if (n > 0) => n * fac(n-1) 
    case _            => 1
  }

Digression: About Those Types...

Unlike ML, you have to write down some types in Scala.

Must write argument types for all functions.

Must write return types for recursive functions.
(Of course, you can also write them for non-recursive functions.)

scala> def fac(n: Int) =
     |   n match {
     |     case n if (n > 0) => n * fac(n-1) 
     |     case _            => 1
     |   }
error: recursive method fac needs result type ...

Scala's Local Type Inference figures out the rest!

Digression: Zero-Argument Functions...

scala> def f() = 1
f: ()Int

scala> f()
res1: Int = 1

Can be called without parentheses:

scala> f
res2: Int = 1

Control Expressions: Try-Catch

Put the body expression inside {...}.

import java.io.File 
 
def fileContents(file: String): List[String] = {
  val f = new java.io.File(file)
  try {
    scala.io.Source.fromFile(f).getLines().toList
  } catch {
    case e: java.io.FileNotFoundException => {
      println("WTF! No such file exists")
      List()
    }
  }
}

Control Expressions: Try-Catch (contd.)

Create a file called file.txt with some lines of text.

Try running:

scala> val lines = fileContents("file.txt")
lines: List[String] = List(Hello, world)

Try running it with a junk file:

scala> fileContents("foobar")
WTF! No such file exists
res10: List[String] = List()

Control Expressions: `while`-loops

Old-school while loops:

def fac(n: Int) = {
  var res   = 1
  var count = n
  while (count > 0) {
    res   *= count
    count -= 1
  }
  res
}

Control Expressions: `for`-loops

And, of course, for-loops, too:

scala> for (i <- 1 to 5) println(i)
1
2
3
4
5

Control Expressions: `for`-loops

Or, if you want to step by something other than 1 ...

scala> for (i <- 1 to 5 by 2) println(i)
1
3
5

Control Expressions: `for`-loops

Or, count in the other direction ...

scala> for (i <- 5 to 1 by -1) println(i)
5
4
3
2
1

Control Expressions: `for`-loops

Actually, for-loops are quite special.

scala> for (i <- "special") println(i)
s
p
e
c
i 
a
l

Hmm, what's going on?

Scala Collections (Batteries Included)

Batteries Included: Collections

Scala bundled with with a rich set of Collections

Arrays
Lists
(Hash) Sets
(Hash) Maps
Streams ...

Some are immutable. Some are mutable.

Batteries Included: Arrays

(Mutable) Arrays

scala> val a = Array("cow", "dog", "mouse")
res14: Array[java.lang.String] = Array(cow, dog, mouse)

Note the type: Array[String].

Arrays have a fixed length

scala> a.length
res15: Int = 3

Batteries Included: Arrays

(Mutable) Arrays can be randomly accessed.

scala> a(2)
res16: java.lang.String = mouse

"Uniform Access Principle"

a(2) read as lookup method call a.apply(2)

Batteries Included: Arrays

(Mutable) Arrays can be randomly updated.

scala> a(0) = "aardvark"

scala> a
res19: Array[java.lang.String] =
         Array(aardvark, dog, mouse)

"Uniform Access Principle"

a(0) = "aardvark" read as update method call
a.update(0, "aardvark")

Batteries Included: `for`-loops

(Mutable) Arrays can also be looped over...

scala> for (animal <- a) println(animal)
aardvark
dog
mouse

"Off-by-one" errors BEGONE!

But immutable better if you can help it...

Batteries Included: Lists

(Immutable) Lists

scala> val xs = List(1,2,3,4)
xs: List[Int] = List(1, 2, 3, 4)

scala> val ys = List("cat", "dog", "moose", "goose")
ys: List[java.lang.String] =
      List(cat, dog, moose, goose)

Cannot change a list!

scala> ys(0) = "kite"
error: value update is not a member of
       List[java.lang.String] ...

Batteries Included: Lists

Quite a bit like ML lists.

scala> val zs = "chicken" :: ys
zs: List[java.lang.String] =
      List(chicken, cat, dog, moose, goose)

Can be accessed via pattern-matching:

def listConcat(xs: List[String]): String =  
  xs match {
    case Nil  => "" 
    case h::t => h + listConcat(t)
  }

Which you can call like so:

scala> listConcat(zs)
res10: chickencatdogmoosegoose

Batteries Included: Lists

You can also append lists.

scala> List(1,2,3) ++ List(4,5,6)
res11: List[Int] = List(1,2,3,4,5,6)

Alternate syntax:

scala> List(1,2,3) ::: List(4,5,6)
res11: List[Int] = List(1,2,3,4,5,6)