A Crash Course in Scala Amir H. Payberah
[email protected] KTH Royal Institute of Technology 2016/09/09
Amir H. Payberah (KTH)
Scala
2016/09/09
1 / 73
Scala
I
Scala: scalable language
I
A blend of object-oriented and functional programming.
I
Runs on the Java Virtual Machine.
I
Designed by Martin Odersky at EPFL.
Amir H. Payberah (KTH)
Scala
2016/09/09
2 / 73
Cathedral vs. Bazaar
I
Two metaphors for software development (Eric S. Raymond)
Amir H. Payberah (KTH)
Scala
2016/09/09
3 / 73
Cathedral vs. Bazaar I
The cathedral • •
I
A near-perfect building that takes a long time to build. Once built, it stays unchanged for a long time.
The bazaar • •
Adapted and extended each day by the people working in it. Open-source software development.
Amir H. Payberah (KTH)
Scala
2016/09/09
4 / 73
Cathedral vs. Bazaar I
The cathedral • •
I
A near-perfect building that takes a long time to build. Once built, it stays unchanged for a long time.
The bazaar • •
Adapted and extended each day by the people working in it. Open-source software development.
Scala is much more like a bazaar than a cathedral! Amir H. Payberah (KTH)
Scala
2016/09/09
4 / 73
Functional Programming (FP) I
In a restricted sense: programming without mutable variables, assignments, loops, and other imperative control structures.
I
In a wider sense: focusing on the functions.
Amir H. Payberah (KTH)
Scala
2016/09/09
5 / 73
Functional Programming (FP) I
In a restricted sense: programming without mutable variables, assignments, loops, and other imperative control structures.
I
In a wider sense: focusing on the functions.
I
Functions can be values that are produced, consumed, and composed.
Amir H. Payberah (KTH)
Scala
2016/09/09
5 / 73
FP Languages (1/2)
I
In a restricted sense: a language that does not have mutable variables, assignments, or imperative control structures.
I
In a wider sense: it enables the construction of programs that focus on functions.
Amir H. Payberah (KTH)
Scala
2016/09/09
6 / 73
FP Languages (1/2)
I
In a restricted sense: a language that does not have mutable variables, assignments, or imperative control structures.
I
In a wider sense: it enables the construction of programs that focus on functions.
I
Functions are first-class citizens: • • •
Defined anywhere (including inside other functions). Passed as parameters to functions and returned as results. Operators to compose functions.
Amir H. Payberah (KTH)
Scala
2016/09/09
6 / 73
FP Languages (2/2)
I
In the restricted sense: •
I
Pure Lisp, XSLT, XPath, XQuery, Erlang
In the wider sense: •
Lisp, Scheme, Racket, Clojure, SML, Ocaml, Haskell (full language), Scala, Smalltalk, Ruby
Amir H. Payberah (KTH)
Scala
2016/09/09
7 / 73
Amir H. Payberah (KTH)
Scala
2016/09/09
8 / 73
The “Hello, world!” Program
object HelloWorld { def main(args: Array[String]) { println("Hello, world!") } }
Amir H. Payberah (KTH)
Scala
2016/09/09
9 / 73
Run It Interactively!
> scala This is a Scala shell. Type in expressions to have them evaluated. Type :help for more information. scala> object HelloWorld { | def main(args: Array[String]) { | println("Hello, world!") | } | } defined module HelloWorld scala> HelloWorld.main(null) Hello, world! scala>:q >
Amir H. Payberah (KTH)
Scala
2016/09/09
10 / 73
Compile and Execute It!
// Compile it! > scalac HelloWorld.scala > scalac -d classes HelloWorld.scala // Execute it! > scala HelloWorld > scala -cp classes HelloWorld
Amir H. Payberah (KTH)
Scala
2016/09/09
11 / 73
Script It!
# script.sh #!/bin/bash exec scala $0 $@ !# object HelloWorld { def main(args: Array[String]) { println("Hello, world!") } } HelloWorld.main(null) # Execute it! > ./script.sh
Amir H. Payberah (KTH)
Scala
2016/09/09
12 / 73
Outline
I
Scala basics
I
Functions
I
Collections
I
Classes and objects
I
SBT
Amir H. Payberah (KTH)
Scala
2016/09/09
13 / 73
Outline
I
Scala basics
I
Functions
I
Collections
I
Classes and objects
I
SBT
Amir H. Payberah (KTH)
Scala
2016/09/09
13 / 73
Scala Variables
I
Values: immutable
I
Variables: mutable
var myVar: Int = 0 val myVal: Int = 1 // Scala figures out the type of variables based on the assigned values var myVar = 0 val myVal = 1 // If the initial values are not assigned, it cannot figure out the type var myVar: Int val myVal: Int
Amir H. Payberah (KTH)
Scala
2016/09/09
14 / 73
Scala Data Types I
Boolean: true or false
I
Byte: 8 bit signed value
I
Short: 16 bit signed value
I
Char: 16 bit unsigned Unicode character
I
Int: 32 bit signed value
I
Long: 64 bit signed value
I
Float: 32 bit IEEE 754 single-precision float
I
Double: 64 bit IEEE 754 double-precision float
I
String: A sequence of characters
var myInt: Int var myString: String
Amir H. Payberah (KTH)
Scala
2016/09/09
15 / 73
If ... Else
var x = 30; if (x == 10) { println("Value of X is 10"); } else if (x == 20) { println("Value of X is 20"); } else { println("This is else statement"); }
Amir H. Payberah (KTH)
Scala
2016/09/09
16 / 73
Loops (1/3)
var a = 10 // do-while do { println("Value of a: " + a) a = a + 1 } while(a < 20) // while loop execution while(a < 20) { println("Value of a: " + a) a = a + 1 }
Amir H. Payberah (KTH)
Scala
2016/09/09
17 / 73
Loops (2/3)
var a = 0 var b = 0 for (a Long) { println("In delayed method") println("Param: " + t) } delayed2(time()) In delayed method Getting time in nano seconds Param: 2532875587194574
Amir H. Payberah (KTH)
Scala
2016/09/09
29 / 73
Functions - Partial Applied
I
If you do not pass in arguments for all of the parameters.
def adder(m: Int, n: Int, p: Int) = m + n + p val add2 = adder(2, _: Int, _: Int) add2(3, 5)
Amir H. Payberah (KTH)
Scala
2016/09/09
30 / 73
Functions - Currying (1/2)
I
Transforms a function with multiple arguments into a chain of functions, each accepting a single argument and returning another function.
I
For example transforms f(x, y, z) // (int,int,int) -> int to g(x)(y)(z) // int -> (int -> (int -> int)), in which g(x) returns another function, h(y) that takes an argument and returns k(z).
I
Used to partially apply a function to some value while leaving other values undecided,
Amir H. Payberah (KTH)
Scala
2016/09/09
31 / 73
Functions - Currying (2/2)
def adder(m: Int)(n: Int)(p: Int) = m + n + p adder: (m: Int)(n: Int)(p: Int)Int // // // //
The above definition does not return a curried function yet (adder: (m: Int)(n: Int)(p: Int)Int) To obtain a curried version we still need to transform the method. into a function value.
val currAdder = adder _ currAdder: Int => Int => Int => Int = val add2 = currAdder(2) val add5 = add2(3) add5(5)
Amir H. Payberah (KTH)
Scala
2016/09/09
32 / 73
Outline
I
Scala basics
I
Functions
I
Collections
I
Classes and objects
I
SBT
Amir H. Payberah (KTH)
Scala
2016/09/09
33 / 73
Collections
I
Scala collections can be mutable and immutable collections.
I
Mutable collections can be updated or extended in place.
I
Immutable collections never change: additions, removals, or updates operators return a new collection and leave the old collection unchanged.
Amir H. Payberah (KTH)
Scala
2016/09/09
34 / 73
Collections
I
Arrays
I
Lists
I
Sets
I
Maps
I
Tuples
I
Option
Amir H. Payberah (KTH)
Scala
2016/09/09
35 / 73
Collections - Arrays
I
A fixed-size sequential collection of elements of the same type
I
Mutable
// Array definition val t: Array[String] = new Array[String](3) val t = new Array[String](3)
// Assign values or get access to individual elements t(0) = "zero"; t(1) = "one"; t(2) = "two"
// There is one more way of defining an array val t = Array("zero", "one", "two")
Amir H. Payberah (KTH)
Scala
2016/09/09
36 / 73
Collections - Lists I
A sequential collection of elements of the same type
I
Immutable
I
Lists represent a linked list
// List definition val l1 = List(1, 2, 3) val l1 = 1 :: 2 :: 3 :: Nil // Adding an element to the head of a list val l2 = 0 :: l1 // Adding an element to the tail of a list val l3 = l1 :+ 4 // Concatenating lists val t3 = List(4, 5) val t4 = l1 ::: t3
Amir H. Payberah (KTH)
Scala
2016/09/09
37 / 73
Collections - Sets I
A sequential collection of elements of the same type
I
Immutable and mutable
I
No duplicates.
// Set definition val s = Set(1, 2, 3) // Add a new element to the set val s2 = s + 0 // Remove an element from the set val s3 = s2 - 2 // Test the membership s.contains(2)
Amir H. Payberah (KTH)
Scala
2016/09/09
38 / 73
Collections - Maps I
A collection of key/value pairs
I
Immutable and mutable
// Map definition var m1: Map[Char, Int] = Map() val m2 = Map(1 -> "Carbon", 2 -> "Hydrogen") // Finding the element associated to a key in a map m2(1) // Adding an association in a map val m3 = m2 + (3 -> "Oxygen") // Returns an iterable containing each key (or values) in the map m2.keys m2.values
Amir H. Payberah (KTH)
Scala
2016/09/09
39 / 73
Collections - Tuples
I
A fixed number of items of different types together
I
Immutable
// Tuple definition val t = (1, "hello", Console) val t = new Tuple3(1, "hello", 20) // Tuple getters t._1 t._2 t._3
Amir H. Payberah (KTH)
Scala
2016/09/09
40 / 73
Collections - Option (1/2)
I
Sometimes you might or might not have a value.
I
Java typically returns the value null to indicate nothing found. •
I
Scala has a null value in order to communicate with Java. •
I
You may get a NullPointerException, if you don’t check it.
You should use it only for this purpose.
Everyplace else, you should use Option.
Amir H. Payberah (KTH)
Scala
2016/09/09
41 / 73
Collections - Option (2/2)
scala> val numbers = Map(1 -> "one", 2 -> "two") numbers: scala.collection.immutable.Map[Int, String] = Map((1, one), (2, two)) scala> numbers.get(2) res0: Option[String] = Some(two) scala> numbers.get(3) res1: Option[String] = None // Check if an Option value is defined (isDefined and isEmpty). scala> val result = numbers.get(3).isDefined result: Boolean = false // Extract the value of an Option. scala> val result = numbers.get(3).getOrElse("zero") result: String = zero
Amir H. Payberah (KTH)
Scala
2016/09/09
42 / 73
Functional Combinators
I
map
I
foreach
I
filter
I
zip
I
partition
I
find
I
drop and dropWhile
I
foldRight and foldLeft
I
flatten
I
flatMap
Amir H. Payberah (KTH)
Scala
2016/09/09
43 / 73
Functional Combinators - map I
Evaluates a function over each element in the list, returning a list with the same number of elements
scala> val numbers = List(1, 2, 3, 4) numbers: List[Int] = List(1, 2, 3, 4)
scala> numbers.map((i: Int) => i * 2) res0: List[Int] = List(2, 4, 6, 8)
scala> def timesTwo(i: Int): Int = i * 2 timesTwo: (i: Int)Int
scala> numbers.map(timesTwo _) or scala> numbers.map(timesTwo) res1: List[Int] = List(2, 4, 6, 8)
Amir H. Payberah (KTH)
Scala
2016/09/09
44 / 73
Functional Combinators - foreach
I
It is like map but returns nothing
scala> val numbers = List(1, 2, 3, 4) numbers: List[Int] = List(1, 2, 3, 4)
scala> val doubled = numbers.foreach((i: Int) => i * 2) doubled: Unit = ()
scala> numbers.foreach(print) 1234
Amir H. Payberah (KTH)
Scala
2016/09/09
45 / 73
Functional Combinators - filter I
Removes any elements where the function you pass in evaluates to false
scala> val numbers = List(1, 2, 3, 4) numbers: List[Int] = List(1, 2, 3, 4)
scala> numbers.filter((i: Int) => i % 2 == 0) res0: List[Int] = List(2, 4)
scala> def isEven(i: Int): Boolean = i % 2 == 0 isEven: (i: Int)Boolean
scala> numbers.filter(isEven) res2: List[Int] = List(2, 4)
Amir H. Payberah (KTH)
Scala
2016/09/09
46 / 73
Functional Combinators - zip
I
Aggregates the contents of two lists into a single list of pairs
scala> val numbers = List(1, 2, 3, 4) numbers: List[Int] = List(1, 2, 3, 4) scala> val chars = List("a", "b", "c") chars: List[String] = List(a, b, c) scala> numbers.zip(chars) res0: List[(Int, String)] = List((1, a), (2, b), (3, c))
Amir H. Payberah (KTH)
Scala
2016/09/09
47 / 73
Functional Combinators - partition
I
Splits a list based on where it falls with respect to a predicate function
scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> numbers.partition(_ % 2 == 0) res0: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10), List(1, 3, 5, 7, 9))
Amir H. Payberah (KTH)
Scala
2016/09/09
48 / 73
Functional Combinators - find
I
Returns the first element of a collection that matches a predicate function
scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> numbers.find(i => i > 5) res0: Option[Int] = Some(6)
Amir H. Payberah (KTH)
Scala
2016/09/09
49 / 73
Functional Combinators - drop and dropWhile
I
drop drops the first i elements
I
dropWhile removes the first elements that match a predicate function
scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) scala> numbers.drop(5) res0: List[Int] = List(6, 7, 8, 9, 10) scala> numbers.dropWhile(_ % 3 != 0) res1: List[Int] = List(3, 4, 5, 6, 7, 8, 9, 10)
Amir H. Payberah (KTH)
Scala
2016/09/09
50 / 73
Functional Combinators - foldLeft I
It goes through the whole List, from head to tail, and passes each value to f.
I
For the first list item, that first parameter, z, is used as the first parameter to f.
I
For the second list item, the result of the first call to f is used as the B type parameter.
def foldLeft[B](z: B)(f: (B, A) => B): B scala> val numbers = List(1, 2, 3, 4, 5) scala> numbers.foldLeft(0) { (m, n) => println("m: " + m + " n: " + n); m + n } m: 0 n: 1 m: 1 n: 2 m: 3 n: 3 m: 6 n: 4 m: 10 n: 5 res0: Int = 15 Amir H. Payberah (KTH)
Scala
2016/09/09
51 / 73
Functional Combinators - foldRight
I
It is the same as foldLeft except it runs in the opposite direction
def foldRight[B](z: B)(f: (A, B) => B): B scala> val numbers = List(1, 2, 3, 4, 5) scala> numbers.foldRight(0) { (m, n) => println("m: " + m + " n: " + n); m + n } m: 5 n: 0 m: 4 n: 5 m: 3 n: 9 m: 2 n: 12 m: 1 n: 14 res52: Int = 15
Amir H. Payberah (KTH)
Scala
2016/09/09
52 / 73
Functional Combinators - flatten
I
It collapses one level of nested structure
scala> List(List(1, 2), List(3, 4)).flatten res0: List[Int] = List(1, 2, 3, 4)
Amir H. Payberah (KTH)
Scala
2016/09/09
53 / 73
Functional Combinators - flatMap
I
It takes a function that works on the nested lists and then concatenates the results back together
scala> val nestedNumbers = List(List(1, 2), List(3, 4)) nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4)) scala> nestedNumbers.flatMap(x => x.map(_ * 2)) res0: List[Int] = List(2, 4, 6, 8) // Think of it as short-hand for mapping and then flattening: scala> nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten res1: List[Int] = List(2, 4, 6, 8)
Amir H. Payberah (KTH)
Scala
2016/09/09
54 / 73
Outline
I
Scala basics
I
Functions
I
Collections
I
Classes and objects
I
SBT
Amir H. Payberah (KTH)
Scala
2016/09/09
55 / 73
Everything is an Object
I
Scala is a pure object-oriented language.
I
Everything is an object, including numbers.
1 + 2 * 3 / x (1).+(((2).*(3))./(x))
I
Functions are also objects, so it is possible to pass functions as arguments, to store them in variables, and to return them from other functions.
Amir H. Payberah (KTH)
Scala
2016/09/09
56 / 73
Classes and Objects
class Calculator { val brand: String = "HP" def add(m: Int, n: Int): Int = m + n } val calc = new Calculator calc.add(1, 2) println(calc.brand)
Amir H. Payberah (KTH)
Scala
2016/09/09
57 / 73
Constructors
class Calculator(brand: String) { // A constructor. val color: String = if (brand == "TI") { "blue" } else if (brand == "HP") { "black" } else { "white" } // An instance method. def add(m: Int, n: Int): Int = m + n } val calc = new Calculator("HP") println(calc.color)
Amir H. Payberah (KTH)
Scala
2016/09/09
58 / 73
Inheritance and Overloading Methods
I
Scala allows the inheritance from just one class only.
class SciCalculator(brand: String) extends Calculator(brand) { def log(m: Double, base: Double) = math.log(m) / math.log(base) } class MoreSciCalculator(brand: String) extends SciCalculator(brand) { def log(m: Int): Double = log(m, math.exp(1)) }
Amir H. Payberah (KTH)
Scala
2016/09/09
59 / 73
Singleton Objects I
A singleton is a class that can have only one instance.
class Point(val xc: Int, val yc: Int) { var x: Int = xc var y: Int = yc } object Test { def main(args: Array[String]) { val point = new Point(10, 20) printPoint def printPoint { println ("Point x location : " + point.x); println ("Point y location : " + point.y); } } } Test.main(null)
Amir H. Payberah (KTH)
Scala
2016/09/09
60 / 73
Abstract Classes
abstract class Shape { // subclass should define this def getArea(): Int } class Circle(r: Int) extends Shape { def getArea(): Int = { r * r * 3 } } val s = new Shape // error: class Shape is abstract val c = new Circle(2) c.getArea
Amir H. Payberah (KTH)
Scala
2016/09/09
61 / 73
Traits
I
A class can mix in any number of traits.
trait Car { val brand: String } trait Shiny { val shineRefraction: Int } class BMW extends Car with Shiny { val brand = "BMW" val shineRefraction = 12 }
Amir H. Payberah (KTH)
Scala
2016/09/09
62 / 73
Generic Types
trait def def def }
Cache[K, V] { get(key: K): V put(key: K, value: V) delete(key: K)
def remove[K](key: K)
Amir H. Payberah (KTH)
Scala
2016/09/09
63 / 73
Case Classes and Pattern Matching I
Case classes are used to store and match on the contents of a class.
I
They are designed to be used with pattern matching.
I
You can construct them without using new.
scala> case class Calculator(brand: String, model: String) scala> val hp20b = Calculator("hp", "20B") def calcType(calc: Calculator) = calc match { case Calculator("hp", "20B") => "financial" case Calculator("hp", "48G") => "scientific" case Calculator("hp", "30B") => "business" case _ => "Calculator of unknown type" } scala> calcType(hp20b)
Amir H. Payberah (KTH)
Scala
2016/09/09
64 / 73
Outline
I
Scala basics
I
Functions
I
Collections
I
Classes and objects
I
SBT
Amir H. Payberah (KTH)
Scala
2016/09/09
65 / 73
Simple Build Tool (SBT)
I
An open source build tool for Scala and Java projects.
I
Similar to Java’s Maven or Ant.
I
It is written in Scala.
Amir H. Payberah (KTH)
Scala
2016/09/09
66 / 73
SBT - Hello World!
$ mkdir hello $ cd hello $ cp /HelloWorld.scala . $ sbt ... > run
Amir H. Payberah (KTH)
Scala
2016/09/09
67 / 73
Running SBT I
Interactive mode
$ sbt > compile > run
I
Batch mode
$ sbt clean run
I
Continuous build and test: automatically recompile or run tests whenever you save a source file.
$ sbt > ~ compile
Amir H. Payberah (KTH)
Scala
2016/09/09
68 / 73
Common Commands I
clean: deletes all generated files (in target).
I
compile: compiles the main sources (in src/main/scala).
I
test: compiles and runs all tests.
I
console: starts the Scala interpreter.
I
run *: run the main class.
I
package: creates a jar file containing the files in src/main/resources
and the classes compiled from src/main/scala. I
help : displays detailed help for the specified command.
I
reload:
reloads the build definition (build.sbt, project/*.scala, project/*.sbt files).
Amir H. Payberah (KTH)
Scala
2016/09/09
69 / 73
Create a Simple Project
I
Create project directory.
I
Create src/main/scala directory.
I
Create build.sbt in the project root.
Amir H. Payberah (KTH)
Scala
2016/09/09
70 / 73
build.sbt
I
A list of Scala expressions, separated by blank lines.
I
Located in the project’s base directory.
$ cat build.sbt name := "hello" version := "1.0" scalaVersion := "2.11.5"
Amir H. Payberah (KTH)
Scala
2016/09/09
71 / 73
Add Dependencies
I
Add in build.sbt.
I
Module ID format: "groupID" %% "artifact" % "version" % "configuration"
libraryDependencies += "org.apache.spark" %% "spark-core" % "0.9.0-incubating" // multiple dependencies libraryDependencies ++= Seq( "org.apache.spark" %% "spark-core" % "1.6.2-incubating", "org.apache.spark" %% "spark-streaming" % "1.6.2-incubating" )
Amir H. Payberah (KTH)
Scala
2016/09/09
72 / 73
Questions?
Amir H. Payberah (KTH)
Scala
2016/09/09
73 / 73
