Many Resources

Online

Martin Odersky's First Steps in Scala
Twitter's Scala School
Matt Might's Scala In Small Bites
API Search Engine scalex.org

Books

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

Lets 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.11.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_55).
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
         ^

Fair enough.

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 = Fri May 15 11:31:36 PDT 2015

So every Java library in the known universe trivially usable in Scala.

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

Immutable Variables

With the val keyword

scala> val x = 2
x: Int = 2

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

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

Snap.

... and if you absolutely must: Immutable 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 ameneties 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))

the type is written (T1, T2) or (T1, T2, T3)

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

Functions

Many ways to define functions

def inc(x) = {
  x + 1
}

Call a function in the usual way

scala> inc(4)
res3: Int = 5

Functions

No need for explicit return

def adder(x: Int, y: Int): Int = {
  println("thou calleth adder with (x=%d, y=%d)".format(x, y))
  val z = x + y
  println("thou getteth (z=%d)".format(z))
  z
}

Block evaluates to last expression

scala> adder(2, 3)
thou calleth adder with (x=2, y=3)
res1: Int = 5

Curried Functions

def curriedAdder(x: Int)(y: Int): Int = {
  println("You called curried adder: %d %d". format(x, y))
  x + y
}

// let curriedAdder  x y = x + y

which is called thus

scala> curriedAdder(2)(3)
You called curried adder: 2 3
res0: Int = 5

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>

Note the types of the functions

Functions with no name

Call by placing argument in front

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

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

object inc {
  val a = 10
  val b = 20
  def apply(x: Int) = x + 1
}

object go {
  def apply(x: Any) = "go away"
}

Call them like so

scala> inc(5)
res: Int = 6

scala> go(10)
res: String = go away

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

Put the then and else expressions inside {...}

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


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

What happens without type signature?

Control Expressions: Pattern Matching (FTW!)

Scala has pattern matching too ...

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

... more on this later.

Digression: About Those Types...

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

Function arguments and returns

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

Scala's Local Type Inference figures out the rest!

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)
  scala.io.Source.fromFile(f).getLines().toList
  }

def fileContents(file: String): List[String] = {
  try {
    val f = new java.io.File(file)
    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.)

You can run it thus:

scala> val lines = fileContents("lec-scalacrash.markdown")
lines: List[String] = List(% CSE 130: Fall 2015, ...)

and if you call it with a junk file:

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

Control Expressions: While-loop

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-loop

... and of course, for-loops too...

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

Control Expressions: For-loop

Or if you want a step...

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

Control Expressions: For-loop

Or count in the other direction ...

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

Control Expressions: For-loop

Actually, for-loops are quite special ...

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

Hmm. Whats going on?

Scala Batteries Included: Collections

Batteries Included: Collections

Scala bundled with with a rich set of Collections

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

These are immutable OR 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) = "capuchin"

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

"Uniform access principle"

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

Batteries Included: For-Loops

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

//JAVA-WORST
for (i = 0; i < a.length; i++) {
  println(a(i))
}

//SCALA-BAD
for (i <- 0 to a.length) {
  println(a(i))
}

//SCALA GOOD!!!
for (animal <- a) println(animal)

// SHORTER IS BETTER ...
// LESS MUTABLE IS BETTER ...
// FEWER PLACES TO GO WRONG THE BETTER!

Loathsome "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", "gorilla")
ys: List[java.lang.String] = List(cat, dog, moose, gorilla)

Buuut... Cannot change a list!!

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

Batteries Included

Quite a bit like ML lists...

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

Quiz

val ys  = List("cat", "dog", "godzilla")
val res = 12 :: ys

What is the value of res ?

A. List("12", "cat", "dog", "godzilla")

B. List(12, "cat", "dog", "godzilla")

C. Type Error

D. Other Unspecified Compiler Angst

Batteries Included

Lists 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(ys)
res10: chickencatdogmoosegorilla

Batteries Included

(Immutable) Lists

You can also append them

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

and, loop over them too ...

scala> for (animal <- zs) println(animal)
chicken
cat
dog
moose
gorilla

Batteries Included: Hash-Maps