[Scala] [Coursera]

Week 1

Cheat Sheet

• Link

Evaluation Rules

• Call by value: evaluates the function arguments before calling the funtion
• Call by name: evaluates the function first, and then evaluates the arguments if need be

• val example = 2    // evaluated immediately
  def example = 2    //evaluated when called
  laze val example = 2   // evaluated once when needed
  
  def square(x : Double)    // call by value
  def square(x: => Double)   // call by name
  def myFct(bindings: Int*) = { ... }    // bindings is a sequence of int, containing a varying # of arguments

Higher order functions

• Higher order functions are functions that take a function as a paremeter or return functions.

• // sum() returns a function that takes two integers and returns an integer
  def sum(f: Int => Int): (Int, Int) => Int = {
    def sumf(a: Int, b: int): Int = {...}
    sumf
  }
  
  // same as above. Its type is (Int => Int) => (Int, Int) => Int
  def sum(f: Int => Int)(a: Int, b: Int): Int = {...}
  
  // called like this
  sum((x: Int) => x * x * x)    // Anonymous function, i.e. does not have a name
  sum(x => x * x * x)           // Same anonymous function with type inferred
  
  def cube(x: Int) = x * x * x
  sum(x => x * x * x)(1, 10)    // sum of cubes from 1 to 10
  sum(cube)(1, 10)    // same as above

Currying

• Curring is converting a function with multiple arguments into a function with a single argument that returns another function.

• def f(a: Int, b: Int): Int    // uncurried version(type is (Int, Int) => Int)
  def f(a: Int)(b:Int): Int    // curried version(type is Int => Int => Int)

Classes

• class MyClass(x: Int, y: Int) {
    require(y > 0, "y must be positive")   // precondition, triggering an IllegalArgumentException if not met
  
    def this(x: Int) = {...}   // auxiliary construtor
  
    def nb1 = x    // public method computed every time it is called
    def nb2 = y
  
    private def test(a: Int): Int  = {...}
  
    val nb3 = x + y    // computed only once
    override def toString = member1 + "," + member2
  }
  
  new MyClass(1, 2)

Class hierarchies

• to create an runnable application in scala

  object Hello {
    def main(args: Array[String]) = println("H")
  }
  
  // or
  
  object Hello extends App {
    println("H")
  }

Class Organization

• Classes and objects are organized in pakages.
• Traits are similar to Java interfaces, except they can have non-abstract members:trait Planar { ... } class Square extends Shape with Planar.
• General object hierarchy:
  • scala.Any is base type of all types. Has methods hashCode and toString that can be overridden.
  • scala.AnyVal is base type of all primitive types, such as scala.Double, scala.Float, etc.
  • scala.AnyRef is base type of all reference types. Alias of java.lang.Object, supertype of java.lang.String, scala.List, any user-defined class.
  • scala.Null is a subtype of scala.AnyRef(null is the only instance of type Null), and scala.Nothing is a subtype of any other type without any instance.

Pattern Matching

• Pattern matching is used for decomposing data structures.

  unknownObject match {
    case MyClass(n) => ...
    case MyClass2(a, b) => ...
  }
  
  (someList: List[T]) match {
    case Nil => ...   // empty list
    case x :: Nil => ...   // list with only one element
    case List(x) => ...  // same as above
    case x :: xs => ...   // a list with at least one element. x is bound to the head, xs to the tail. xs could be Nil or some other list
    case 1 :: 2 :: cs => ...   // list that starts with 1 and then 2
    case (x, y) :: ps) => ...  // a list where the head element is a pair
    case _ => ...    // default case if none of the above matches
  }

Options

• Pattern matching can also be used for Option values.
• Some functions (like map.get) return a value of type Option[T] which is either a value of the type Some[T] or the value None

  val myMap = Map("a" -> 42, "b" -> 43)
  def getMapValue(s: Stringf): String = {
    myMap get s match {
      case Some(nb) => "Value found: " + nb
      case None => "None value found"
    }
  }
  
  getMapValue("a")  // "Value found: 42"
  getMapValue("c")  // "No value found"

• Most of the times when u write a pattern match on an option value, the same expression can be written more concisely using combinator methods of the Option class. Eg:

  def getMapValue(s: String): String = myMap.get(s).map("Value found: " + _).getOrElse("No value found")

Pattern Matching in Anonymous Functions

• val pairs: List[(Char, Int)] = ('a', 2) :: ('b', 3) :: Nil
  val chars: List[Char] = pairs.map(p => p match {
    case (ch, num) => ch
  })
  
  // or instead:
  val chars: Lits[Char] =  pairs map {
    case (ch, num) => ch
  }

Collections

• Scala defines several collection classess

Base Classes

• Iterable (collections u can iterate on)
• Seq (ordered sequences)
• Set
• Map

Immutable Collections

• List (linked list, provides fast sequential access)
• Stream (same as List, expect the tail is evaluated only on demand)
• Vector (array-like type, implemented as tree of blocks, provides fast random access)
• Range (ordered sequence of integers with equal spacing)
• String (Java type, implicitly converted to a character sequence, so you can treat every string like a Seq[Char])
• Map (collection that maps keys to values)
• Set (collection without duplicate elements)

Mutable Collections

• Array (Scala arrays are native JVM arrays at runtime, therefore they are very performant)
• Scala also has mutable maps and sets; these should only be used if there are performance issues with immutable types
• Demo Usage:

  val fruitList = List("apples", "oranges", "pears")
  // Alternative syntax for lists
  val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))   // :: is right-associative
  fruit.head   // "apples"
  fruit.tail    // List("oranges", "pears")
  
  val empty = List()
  val emtpty = Nil
  
  val nums = Vector("louis", "frank", "hiromi")
  nums(1)     // element at index 1, returns "frank", O(logn) time
  nums.updated(2, "helena")   // new vector with a different string at index 2, complexity O(log(n))
  
  val fruitSet = Set("apple", "banana", "pear", "banana")
  fruitSet.size   // returns 3
  
  val r: Range = 1 until 5   // 1, 2, 3, 4
  val s: Range = 1 to 5   // 1, 2, 3, 4, 5
  1 to 10 by 3   // 1, 4, 7, 10
  
  val s = (1 to 6).toSet
  s map (_ + 2)   // adds 2 to each element of the set
  
  val s = "Hello"
  s filter(c => c.isUpper)  // returns "H"
  
  // Operations on sequences
  val xs = List(...)
  xs.length
  xs.last   // last element (exception if xs is empty), O(n) time
  xs.init   // all elements of xs but the last (exception if xs is empty), O(n) time
  xs take n   // first n elements of xs
  xs drop n   // the rest of the collection after taking n elements
  xs(n)   // the nth element of xs, O(n) time
  xs ++ ys    // concatenation, complexity O(n)
  xs zip ys   // returns a list of pairs which groups elements with same index together
  xs unzip   // opposite of zip: returns a pair of two lists
  xs.flatMap f  // applies the function to all elements and concatenates the result
  x +: xs  // creates a new collection with leading element x
  xs :+ x  // creates a new collection with trailing element x

Pairs

• val pair = ("answer", 42)
  val (label, value) = pair
  pair._1
  pair._2