Week 1

Cheat Sheet

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