CSC447

Scala

• Functional and object-oriented PL
  • Java + ML + more
  • Scalable Component Abstractions
• Compiles to JVM
  • Interop: Scala calls Java; Java calls Scala
• Examples
  • Better Java; distributed systems; data science
  • Twitter (Scala School)
  • Apache Spark (Scala, Java, Python, R)
  • Chicago Scala meetup

Scala

• Scala has a REPL
• Boolean, numeric, and string Literals as in Java

  false || true

  1 + 2

  ("hello" + " " + "world").length

• Use of Java's libraries

  val dir = java.io.File ("/tmp")
  dir.listFiles.filter (f => f.isDirectory && f.getName.startsWith ("c"))

Everything Is An Object

• 5:Int is an object with methods

  5.toDouble

• Methods can have symbolic names (See scala.Int)

  5.+ (6)

• scala.runtime.RichInt adds more methods

  5.max (6)

• e1.f(e2) can be written as e1 f e2

  5 + 6
  5 max 6

Mutable Variables

int x = 10;        // declare and initialize x
x = 11;            // assignment to x OK

int x = 10;        // declare and initialize x
x = 11;            // assignment to x OK

var x = 10         // declare and initialize x
x = 11             // assignment to x OK

Immutable Variables

final int x = 10;  // declare and initialize x
x = 11;            // assignment to x fails

Final.java:4: error: cannot assign a value to final variable x

const int x = 10;  // declare and initialize x
x = 11;            // assignment to x fails

final.c:6:3: error: assignment of read-only variable ‘x’

val x = 10         // declare and initialize x
x = 11             // assignment to x fails

final.scala:3: error: reassignment to val

Expression Oriented

(e_1, e_2, ..., e_n)

{e_1; e_2; ...; e_n}

{
  e_1
  e_2
  ...
  e_n
}

Methods

• Parameters require type annotations

  def plus (x:Int, y:Int) : Int = x + y

• Return types
  • can often be inferred
  • but are required for recursive methods
• Body is an expression; its value is returned

Methods

def fact (n:Int) : Int = if n <= 1 then 1 else n * fact (n - 1)

def fact (n:Int) : Int = 
  println ("called with n = %d".format (n))
  if n <= 1 then 
    println ("no recursive call")
    1 
  else
    println ("making recursive call")
    n * fact (n - 1)

Methods versus fields

• def can be used as non-parameterized methods
• val and def differ in when initializer is executed.
• val is strict (execute when declared); def is non-strict (execute when accessed)

scala> class C:
  val x = 1
  def y = 1

scala> :javap -p -c -filter C
public class C {
  private final int x;
  public int x();
       1: getfield      #18                 // Field x:I
  public int y();
       0: iconst_1
  public C();
      10: putfield      #18                 // Field x:I
}          

Mutable fields

scala> class C:
  val x = 1
  var z = 1

scala> :javap -p -c -filter C
public class C {
  private final int x;
  private int z;
  public int x();
       1: getfield      #19                 // Field x:I
  public int z();
       1: getfield      #23                 // Field z:I
  public void z_$eq(int);
       2: putfield      #23                 // Field z:I
  public C();
       6: putfield      #19                 // Field x:I
      11: putfield      #23                 // Field z:I
}          

Scala Type Checking

• Scala performs static type checking

  def f () = 5 - "hello"   // rejected by type checker

• REPL prints types of expressions
• Java to Scala type hierarchy
  • Java primitive types to Scala value types
  • Java reference types to Scala reference types
  • java.lang.Object to scala.AnyRef

Structured Data

• Tuples
  • Fixed number of heterogeneous items
• Lists
  • Variable number of homogeneous items
• Immutable and mutable variants
• Pattern matching

Mutable Lists, Etc.

• Scala Collections guide
• scala.collection
• scala.collection.immutable
• scala.collection.mutable
• java.util is available
• Scala has arrays Array[Int]

Mutability: Fields versus Data

• Field mutability is different from data mutability
• Java mutable linked list with final variable

  final List<Integer> xs = new List<> ();
  xs.add (4); xs.add (5); xs.add (6); // mutating list OK
  xs = new List<> ();                 // reassignment fails

• Scala immutable linked list with var variable

  var xs = List (4, 5, 6)
  xs = 0 :: xs            // reassignment OK
  xs (1) = 7              // mutating list fails    

Immutable Tuples

val p : (Int, String) = (5, "hello")
val x : Int = p(0)

public class Pair<X,Y> {
  final X x;
  final Y y;
  public Pair (X x, Y y) { this.x = x; this.y = y; }
 
  static void f () {
    Pair<Integer, String> p = new Pair<Integer, String> (5, "hello");
    Pair<Integer, String> q = new Pair<> (5, "hello"); // infer type params
    int x = p.x;
  }
}

Pattern Matching Behavior

def a(p:(Int,Int)) = p match
  case (x,y) => x+y

def b(p:(Int,Int)) = 
  val x = p(0)
  val y = p(1)
  x + y

Immutable Linked Lists

• Scala's :: is an infix cons operator

(define xs (cons 11 (cons 21 (cons 31 (cons 41 ())))))

val xs = 11 :: (21 :: (31 :: (41 :: Nil)))

val xs = 11 :: 21 :: 31 :: 41 :: Nil         // right associative

Immutable Linked Lists

• Projection called head and tail in many PLs

(car xs)
(cdr xs)

xs.head
xs.tail

Immutable Linked Lists

• Constructors for linked lists

(list 1 2 (+ 1 2))

List (1, 2, 1 + 2)

Pattern Matching Behavior

def f(xs: List[Int]) = xs match 
  case Nil   => "List is empty"
  case x::xt => "List is non-empty, head is %d".format (x)

def g(xs: List[Int]) = 
  if xs == Nil then "List is empty" 
  else 
    val x : Int = xs.head
    val xt : List[Int] = xs.tail
    "List is non-empty, head is %d".format (x)

Pattern Matching Behavior

def g(xs: List[Int]) = 
  if xs == Nil then "List is empty" 
  else if xs.isInstanceOf[::[Int]] then 
    val xc = xs.asInstanceOf[::[Int]]
    val x : Int = xc.head
    val xt : List[Int] = xc.tail
    "List is non-empty, head is %d".format (x)
  else throw MatchError(xs) 

Nesting patterns

• Patterns can include other patterns

  def f (xs: List[(Int,String)]) = xs match
    case Nil         => "List is empty"
    case _::Nil      => "List has one element"
    case _::(x,_)::_ => s"The second int is ${x}"
  
  val zs = List ((11,"dog"), (21,"cat"), (31,"pig"))
  f(zs)

• Found in ML, Haskell, Rust, Swift, and coming to Java
• _ means don't care

Pattern Matching

• Pattern matching often improves readability

  def f (xs: List[(Int,String)]) = 
    if xs == Nil then "List is empty"
    else if xs.tail == Nil then "List has one element"
    else s"The second int is ${xs.tail.head(0)}"
  
  val zs = List ((11,"dog"), (21,"cat"), (31,"pig"))
  f(zs)

Simple List Operations

• Implement isEmpty, head, tail by pattern matching

def isEmpty (xs:List[Int]) : Boolean = xs match 
  case Nil   => true
  case x::xt => false

def head (xs:List[Int]) : Int = xs match 
  case Nil   => throw NoSuchElementException ()
  case x::xt => x

def tail (xs:List[Int]) : List[Int] = xs match 
  case Nil   => throw NoSuchElementException ()
  case x::xt => xt

Builtin Methods

• Builtin head method from List class

  List (1, 2, 3).head

• head method defined on previous slide

  head (List (1, 2, 3))

Recursive Methods

• Imperative programming typically has
  • mutable programming
  • iteration using while loops
• Functional programming typically has
  • immutable programming
  • iteration using recursion
  • Efficient method calls / recursion

Recursive Methods: Lists

def length (xs:List[Int]) : Int = xs match 
  case Nil   => 0
  case x::xt => 1 + length (xt)

def length [X] (xs:List[X]) : Int = xs match 
  case Nil   => 0
  case x::xt => 1 + length (xt)

def length [X] (xs:List[X]) : Int = xs match 
  case Nil   => 0
  case _::xt => 1 + length (xt)

Type and value parameters

def length [X] (xs:List[X]) : Int = ...

val xs1  = List(11,21,31)
val xs2  = List("a","b","c")
val len1 = length[Int](xs1)
val len2 = length[String](xs2)

• X is a type parameter
  
  • Type parameters in square brackets
• xs is a value parameter
  
  • Value parameters in round brackets (parentheses)
• Types before values
• Types usually inferred for function call

val len1 = length(xs1)
val len2 = length(xs2)

Reasoning

length (List (1, 2, 3))
--> length (1::(2::(3::Nil)))
--> 1 + length (2::(3::Nil))      // y = 1, xt = 2::(3::Nil)
--> 1 + (1 + length (3::Nil))     // y = 2, xt = 3::Nil
--> 1 + (1 + (1 + length (Nil)))  // y = 3, xt = Nil
--> 1 + (1 + (1 + 0))
--> 1 + (1 + 1)
--> 1 + 2
--> 3

def length (xs:List[Int]) : Int = xs match 
  case Nil   => 0
  case _::xt => 1 + length (xt)

Appending Lists

append (1::(2::Nil), 3::Nil)
--> 1::(append (2::Nil, 3::Nil))    // x = 1, xt = 2::Nil
--> 1::(2::(append (Nil, 3::Nil)))  // x = 2, xt = Nil
--> 1::(2::(3::Nil))                // x = 2, xt = Nil

def append [X] (xs:List[X], ys:List[X]) : List[X] = xs match 
  case Nil   => ys
  case x::xt => x::(append (xt, ys))

• Cons cells created with 1 and 2 in head
• Cons cell (3::Nil) is reused (shared)

Appending Lists

• Join two lists with append
• A new list is returned
• The two lists are not modified
• But the second list is shared!

def append [X] (xs:List[X], ys:List[X]) : List[X] = xs match 
  case Nil   => ys
  case x::xt => x::(append (xt, ys))

Appending Lists

• List class has builtin method :::

scala> ((1 to 5).toList) ::: ((10 to 15).toList)
res1: List[Int] = List(1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15)