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