What is Scala?

• A programming language running on the JVM
• Statically typed, combines object-orientation and functional programming
• Concise
• Fully interoperable with Java
• As fast as Java

History

• "Make Java better"
  • 1997 - Pizza and GJ (Odersky, Wadler)
  • 2000 - Java 5 (generics)
• "Make a better Java"
  • first release 2004
  • adoption begins 2007
  • first Scala conference 2008

Adoption

According to StackOverflow and GitHub Scala is used a lot.

Momentum

• scala-lang.org: >100'000 visitors/month
• >16 books in print
  • Selection on scala-lang.org
• >65 active user groups
  • See scala-tribes.org

Philosophy

• Scalable language
  • same concepts in small and large applications
• Deep rather than broad
  • focus on abstraction and composition
• "Growable language" (Guy Steele)
  • embed DSLs/add new types

First Example

Java

public class Person { public final String name; public final int age; Person(String name, int age) { this.name = name; this.age = age; } }

Scala

class Person(val name: String, val age: Int)

Using arrays in...

... Java:

import java.util.ArrayList; ... Person[] people; Person[] minors; Person[] adults; { ArrayList<Person> minorsList = new ArrayList<Person>(); ArrayList<Person> adultsList = new ArrayList<Person>(); for (int i = 0; i < people.length; i++) (people[i].age < 18 ? minorsList : adultsList) .add(people[i]); minors = minorsList.toArray(people); adults = adultsList.toArray(people); }

... and in Scala:

val people: Array[Person] // a tuple in a pattern match: val (minors, adults) = people partition (_.age < 18) // a lambda

Scala Basics

Running Scala

• Compiled to Java bytecode
  • experimental JavaScript backend: Scala.js
• Read-Eval-Print-Loop (REPL)
  • fast turnaround
  • easy experimentation/testing
  • available within many tools: Eclipse IDE, sbt, Scala.jsFiddle, ...

Essentials

• Every value is an object
• Everything is an expression (evaluates to a value)
• Every operation is a method call

Primitives

val x: Int = 10 // type can also be inferred val y = x + 10 // same as x.+(10)

Complex numbers

class Complex(val re: Int, val im: Int) { def +(that: Complex) = new Complex(this.re + that.re, this.im + that.im) // ... override def toString = "%d + %di".format(re, im) } val c1 = new Complex(1, 2) val c2 = new Complex(2, 2) c1 + c2

Everything is an expression

• No statements
• Reduces the need for return and side-effects

Expression examples

def max(x: Int, y: Int) = if (x > y) x else y val res = max(10, 5) var x = 0 val t = { x = x + 10 x - 1 }

What about println?

val x = println("hello, world")

Scala's REPL

$ scala Welcome to Scala version 2.11.4 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0). Type in expressions to have them evaluated. Type :help for more information. scala> 1+2 res0: Int = 3 scala>

• Compiles and executes Scala code immediately
• Start from sbt prompt using 'console'

REPL Commands

scala> :help All commands can be abbreviated, e.g. :he instead of :help. :cp <path> add a jar or directory to the classpath :edit <id>|<line> edit history :help [command] print this summary or command-specific help :history [num] show the history (optional num is commands to show) :h? <string> search the history :imports [name name ...] show import history, identifying sources of names :implicits [-v] show the implicits in scope :javap <path|class> disassemble a file or class name :line <id>|<line> place line(s) at the end of history :load <path> interpret lines in a file :paste [-raw] [path] enter paste mode or paste a file :power enable power user mode :quit exit the interpreter :replay reset execution and replay all previous commands ...

Documentation

• www.scala-lang.org
• The doc site: docs.scala-lang.org
• www.scala-lang.org/documentation/api.html
• API docs: www.scala-lang.org/api/current/

Basics: Arrays

// creating an array given a few integers val arr = Array(6, 4, 2, 0) // Q: what's the type of `arr`? // indexing into an array val elem = arr(2) // length of an array val len = arr.length // creating an empty array of a given size val mt = Array.ofDim[Int](8) // in-place update of a value at a given index mt(7) = 1000 // turning an array into a string val s = mt.mkString("[", ",", "]") println(s)

Command-Line Tools

• For now, we stick to the most simple use case
• Compiling Scala source files:
  scalac -d [outdir] [files]
• Running compiled class files:
  scala -cp [outdir] [application-object]
• What's [application-object]?

Scala Applications

object AppleWatch extends App { def greeting(who: String) = "Hello, " + who + "!" } AppleWatch.greeting("Tim")

• object defines a singleton object
• Among others, singleton objects may extend classes and Java interfaces
• Singleton objects may define methods and fields
• Everything within their body is run when the object is used for the first time
• Extending App turns the object into a Scala application

The main Method

• Applications don't have to extend the App trait
• Instead, a main method can be defined explicitly
• The following object can be run on the command-line as follows:
  scala -cp [outdir] recfun.Main

package recfun object Main { // args: command-line arguments def main(args: Array[String]) { println("hello, world") } }

Recursive Functions

Example: computing the Fibonacci series

• A series of integer numbers in which each number (Fibonacci number) is the sum of the two preceding numbers.
• The Fibonacci series starts as follows: 1, 1, 2, 3, 5, 8, ...

Task: write a recursive function that computes the n-th Fibonacci number:

def fib(n: Int): Int = ???

Lists

• Scala has a comprehensive collections library
• In particular, its standard library provides a number of powerful immutable collection types
• Immutable collections have several advantages over mutable collections, e.g., they enable equational reasoning, and they can safely be accessed concurrently.
• Note: the type List[T] does not have to be imported; it is an alias of scala.collection.immutable.List[T].

Lists: Basics

// create a list given a few integers: scala> val l = List(1, 2, 3, 4) l: List[Int] = List(1, 2, 3, 4) scala> val first = l.head first: Int = 1 scala> val rest = l.tail rest: List[Int] = List(2, 3, 4) // `l` did not change: scala> l res0: List[Int] = List(1, 2, 3, 4) // create a new list using `::` ("cons") scala> val l2 = 10 :: rest l2: List[Int] = List(10, 2, 3, 4) // neither `rest` nor `l` changed: scala> rest res1: List[Int] = List(2, 3, 4) scala> l res2: List[Int] = List(1, 2, 3, 4)

Classes and traits

Classes

• Classes introduce (class) types
• Have members: fields, methods, classes, traits, ...
• Abstract classes may leave members abstract (i.e., without an implementation)
• Instantiation of concrete classes through constructor invocation
• Inheritance:
  
  • Single class inheritance, a class may extend exactly one superclass
  • A class may mix in multiple traits
  • Members may be overridden (explicitly)
  • Subtyping polymorphism

Classes

When compiled, this class will look and behave exactly like the obvious translation to a Java class. No glue code necessary.

abstract class Node[T](val v: T, next: Node[T]) extends List(v, next) { val cache: Int def first: T def children = List(next) override def toString = "Node " + v }

Primary Constructor

• Defined implicitly
• Class parameters are parameters of the primary constructor
• Class body is the body of the primary constructor
• If the superclass constructors take parameters, they have to be passed in the extends clause

abstract class Vehicle(passengers: Int) { println(s"initializing a vehicle for $passengers passengers...") def breakDown(again: Boolean): Unit } abstract class Car(seats: Int, isElectric: Boolean) extends Vehicle(seats) { def start(): Unit def stop(): Unit // ... }

Example

• Write a simple class for modeling cars
• The Car class should have fields for its make, model, and year
• The fields should be set by the primary constructor
• It should provide a toString method showing the values of these fields
• Create a stand-alone Scala application that creates a Car instance and prints it as a string

class Car { //... override def toString: String = "todo" }

Constructor parameters and fields

• Assigning constructor parameters to fields becomes verbose quickly
• A val or var modifier makes a constructor parameter available as a field

class Car(val make: String, val model: String, val year: Int) { override def toString: String = "todo" } new Car("VW", "Golf", 2014)

Auxiliary Constructors

• The primary constructor is implicit
• Auxiliary constructors are introduced using def members with name this
• Auxiliary constructors must invoke an earlier-defined constructor
• The primary constructor is always eventually invoked

class Car(val make: String, val model: String, val year: Int) { def this(make: String, model: String) = this(make, model, 2014) override def toString: String = "todo" } new Car("VW", "Golf")

Traits

• Like Java interfaces, but in addition
  • allow concrete methods, fields, types
• Like Scala classes, but without constructor parameters
• Allow (a form of) multiple inheritance
  • mix-in composition

Exercise: Traits

trait Ordered[A] extends java.lang.Comparable[A] { def < (that: A): Boolean = (this compareTo that) < 0 def > (that: A): Boolean = (this compareTo that) > 0 def <= (that: A): Boolean = (this compareTo that) <= 0 def >= (that: A): Boolean = (this compareTo that) >= 0 } case class Person(val name: String, val age: Int)

Example

• Define a trait Convertable with a method openRooftop
• The openRooftop method should print a simple message
• Create a few cars, some of which mix in the Convertable trait

class Car(val make: String, val model: String) { override def toString: String = "todo" } trait Convertable { def openRooftop(): Unit = ??? }

Functional Programming

What is FP?

• Use of functions (in the mathematical sense)
  • referential transparency (no side-effects)
• Immutable objects
• Functions are values

Scala as a Functional Programming Language

• Use val instead of var
• Immutable collections in the standard library
• Leverage function literals and closures

Function literals

val succ = (x: Int) => x + 1 succ(1)

Equivalent forms

(x: Int) => x + 1 x => x + 1 // infer type _ + x // placeholder notation

Higher-Order Functions

• Functions that take or return functions
• Almost eliminate the need for loops over collections

Higher-Order Functions: Examples

val xs = List(1, 2, 3, 4, 5) xs.foreach(println) val allLessThanTen = xs.forall(_ < 10) xs.map(_ * 2) def findBelow(limit: Int) = persons.filter(_.age < limit)

Collections

• Generic (List[T], Map[K, V])
• Mutable and immutable implementations (default is immutable)
• Uniform return type principle
• No compiler magic!

Examples

val l = List(1, 2, 3) val l2 = l.map(x => x + 1) // easily convert between collection types: val s = l2.toSet // a collection of tuples can easily be turned into a Map: val tuples = Seq("A" -> 0, "B" -> 1, "C" -> 2) val m = tuples.toMap val digit = m("B")

Tuples

• Fixed-size, heterogenous
• Example: val tup: (String, Int) = ("A", 0)
• Alternative syntax: val tup: (String, Int) = "A" -> 0
  • No magic: just the -> extension method
• Pattern matching enabled
• Emulate multiple results and/or multiple variable definitions

val tup: (String, String) = ("Glasgow", "Edinburgh") val from = tup._1 val to = tup._2 tup match { case (from, "Edinburgh") => println("right direction") case (from, to) => println(s"don't want to go to $to today") } def doesManyThings(numPeople: Int): ((String, String), Int) = { val connection = ("Glasgow", "Edinburgh") val price = 100 * numPeople (connection, price) } // multiple results: val (conn, cost) = doesManyThings(1)

Example: Maps

val capitals = Map("France" -> "Paris", "Switzerland" -> "Bern", "Sweden" -> "Stockholm") val someCity = capitals("France") val resOfAdd = capitals + ("Romania" -> "Bucharest") val filtered = capitals.filter(_._2 == "Paris")

Example

• Given a collection of cars (an immutable Seq)
• Compute a collection of the brands that are represented

import scala.collection.immutable.Seq case class Car(make: String, model: String) def brands(cars: Seq[Car]): Set[String] = ???

Example: Solution

• Given a collection of cars (an immutable Seq)
• Compute a collection of the brands that are represented

import scala.collection.immutable.Seq case class Car(make: String, model: String) def brands(cars: Seq[Car]): Set[String] = cars.map(car => car.make).toSet val cs = Seq(Car("VW", "Golf"), Car("BMW", "i3")) brands(cs)

Everything is an object

• Closures are objects, too
• Instances of trait Function1[A, B] (compiler generated)

trait Function1[R, A] { def apply(x: A): R }

Syntactic Sugar

• Why can I call succ(10)?
• f(args) is desugared to f.apply(args)
• You can define your own apply methods
• ...can I subclass FunctionN?

Function Subtypes

• Yes! Many collections are functions.
  • Sequences are Int => T
  • Sets are T => Boolean
  • Maps are K => V

val even = Set(2, 4, 6, 8, 10) val res1 = even(4) val res2 = even(3)

For-comprehensions

• More general than for-loops
• Used to iterate, filter and generate new collections

for (p <- persons; pr <- p.projects; if pr.overdue) yield p.name

For-comprehensions

• Translated to calls to filter, map, flatMap
• Readily available to any class implementing those methods
• Can be used to query a database
  • Implement filter, map, flatmap to generate and forward SQL
  • SLICK, Squeryl

Unit Testing

Building and Testing

• Testing
  • ScalaTest
  • specs2
  • ScalaCheck: generate random test inputs
  • any Java testing framework
• Building
  • Build tools: sbt, Maven, Gradle, ant, ...
  • IntelliJ Survey at Scala Days 2013 (blog):
    

Testing with ScalaTest

import collection.mutable.Stack import org.scalatest._ class ExampleSpec extends FlatSpec with Matchers { "A Stack" should "pop values in last-in-first-out order" in { val stack = new Stack[Int] stack.push(1) stack.push(2) stack.pop() should be (2) stack.pop() should be (1) } it should "throw NoSuchElementException if an empty stack is popped" in { val emptyStack = new Stack[Int] a [NoSuchElementException] should be thrownBy { emptyStack.pop() } } }

ScalaCheck: Property-based testing

import org.scalacheck.Properties import org.scalacheck.Prop.forAll object StringSpecification extends Properties("String") { property("startsWith") = forAll { (a: String, b: String) => (a+b).startsWith(a) } property("concatenate") = forAll { (a: String, b: String) => (a+b).length > a.length && (a+b).length > b.length } property("substring") = forAll { (a: String, b: String, c: String) => (a+b+c).substring(a.length, a.length+b.length) == b } }

Pattern matching

Pattern matching

• A way to match and deconstruct structured data
• A powerful switch statement (expression, really)

abstract class Expr case class Literal(n: Int) extends Expr case class Add(left: Expr, right: Expr) extends Expr case class Mul(left: Expr, right: Expr) extends Expr def opt(e: Expr) = e match { case Add(l, Literal(0)) => l case Mul(l, Literal(1)) => l case _ => e } val expr = Add(Literal(10), Literal(0)) val optimized = opt(expr)

Open-Source Ecosystem

Scala Open Source Project

• Scala compiler, standard library, and modules open-source (BSD license)
  • All source on GitHub: https://github.com/scala/
  • Scala release 2.11.0 has 111 contributors
• Contributions
  • Report issues (https://issues.scala-lang.org/)
  • Help with the documentation (http://docs.scala-lang.org)
  • Fix bugs in compiler and other tools
  • Comprehensive contributing guide

Scala modules

• scala-swing
• scala-async
• scala-pickling
• scala-parser-combinators