CS 152 - Lecture 6

Cay S. Horstmann

Scala Documentation

• Online at http://www.scala-lang.org/api/2.12.4
• Bookmark it right now!
• Use text field in upper right corner to filter classes

  

Categories of List Methods

• Basic methods length head tail isEmpty
• Operators :: :+ ++ == != /: :\
• Access by position (n) take drop dropRight slice indexOf lastIndexOf
• Methods without parameters reverse sorted sum max min
• Methods with unary predicates count exists dropWhile filter find findIndexOf forall partition remove span takeWhile
• Methods with unary function map reverseMap flatMap foreach
• Methods with binary predicate sort
• Methods with binary function reduceLeft reduceRight foldLeft foldRight
• Other intersection union zip zipAll zipWithIndex mkString

List Operators

• :: appends in front, :+ in back

  3 :: List(1, 2) is List(3, 1, 2)
  List(1, 2) :+ 3 is List(1, 2, 3)

• ++ concatenate lists

  List(1, 2) ++ List(3, 4) is List(1, 2, 3, 4) // same as :::

• == and != compare lists

  List("Hello", "World") == List("Hel" + "lo", "Wor" + "ld") 

• /: and :\ later

Operator Precedence and Associativity

• On this calculator, what do you get when you type 1 + 2 * 3?
• What do you get in C++?
• Precedence: Which operator is executed first?

  (1 + 2) * 3
  1 + (2 * 3)

• Associativity: If the same operator occurs twice, is the left or right one executed first? Does 1 - 2 - 3 mean

  (1 - 2) - 3
  1 - (2 - 3)

• In C++, most operators are left-associative. Exception: Assignment

  a = b = 3

Scala Operators

• Function names can be any sequence of opchars: characters other than whitespace, A-Z0-9()[]{}`'".,;
• Operator precedence depends on first character

  (all letters)
  |
  ^
  &
  < >
  = !
  :
  + -
  * / %
  (all other special characters)

• Operators ending in : are right associative; all others are left associative

  a :: b :: Nil is a :: (b :: Nil)

Lists: Access by Position

• Not very efficient for linked lists
• Index values are 0-based
• () are used for indexed access—not []

  List(17, 29)(1) is 29

• slice takes sublist

  List(2, 3, 5, 7).slice(1, 3) is List(3, 5) 

  Arguments to slice(from, to):

  • from is the first index to include
  • to is the first index ≥ from to exclude
• See lab for drop take

Methods with Function Parameters

• Workhorse functions of the library
• You already saw map, filter, reduce
• Others explored in lab
• Instead of looping, build a function and pass it to one of these methods

  def randList(len : Int, n : Int) = 
    (1 to len).map((x : Int) => gen.nextInt(n))

• Some methods return a pair

   List(2,3,5,7).partition(isEven) is (List(2),List(3, 5, 7))

Tuples

• Heterogeneous sequence of elements

  val myFirstTuple = (1, 3.14, "Fred")

• Tuple type (Int, Double, String)
• Access components with methods _1 (!), _2, _3

  val second = myFirstTuple._2

• Or with destructuring

  val (first, second, _) = myFirstTuple

Maps

• If I were stranded on a desert island and could only take one data structure with me, it would be the hash table. — Peter van der Linden
• Construct a map

  val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

• -> operator makes pairs. "Alice" -> 10 is the same as ("Alice", 10)
• Access element

  val alicesScore = scores("Alice")
     // They don't call it a map for nothing
  val fredsScore = scores.getOrElse("Fred", 0)

• Update map (i.e. get new map with updates)

  val newScores = scores + ("Bob" -> 10, "Fred" -> 7)
  val newerScores = newScores - "Alice" // Remove key and value

flatMap

val s = (1 to 4).toList
s.map(x => (x, 0))
    // List((1, 0), (2, 0), (3, 0), (4, 0))

s.map(y => s.map(x => (x, y)))
  // List(List((1,1), (2,1), (3,1), (4,1)),
  //        List((1,2), (2,2), (3,2), (4,2)),
  //        List((1,3), (2,3), (3,3), (4,3)),
  //        List((1,4), (2,4), (3,4), (4,4)))

s.flatMap(y => s.map(x => (x, y)))
  // List((1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), ..., (4, 4)) 

Folding

• The sum of the elements in List(a, b, c) is

  a + b + c = 0 + a + b + c = ((0 + a) + b) + c

• Use foldLeft or the /: operator

  def sum(lst: List[Int]) = (0 /: lst) ((x, y) => x + y)

• The /: indicates the tree shape

    a+b+c
       / \
    a+b   c
     / \
    a   b
   / \
  0   a

• The first argument of the folding function is the partial answer; the second is the new list value to be considered
• To recurse may be divine, but not to recurse is even better:

   def fac(n : Int) = (1 /: (1 to n)) {_ * _}

• The foldRight operator works right-to-left: a + (b + (c + 0))

mkString

• toString produces the familiar List(1, 2, 3)
• What if we want 1 | 2 | 3?

  lst.mkString("|")

  One fewer separator than elements

• What if we want [1 | 2 | 3]?

  lst.mkString("[", "|", "]")

• Nice attention to detail by the library designers

Lab

• You work with a buddy
• One of you writes the code (coder), the other types up answers (scribe)
• When you get stuck, ask your buddy first!
• Switch roles each lab. The previous scribe is the coder for this lab.
• The scribe submits lab work in lab5/report.txt inside the Git repo. Include the coder's name in the report!
• If the coder wants to submit something, that's cool too. Do whatever is easy.

Step 1: Warmup

1. What do take and drop do? Give a brief explanation and an example for each.
2. What is the difference between take and dropRight?
3. Look up the definition of span in Scaladoc. Make an example that demonstrates how span works. What is your example, and what value does it produce?
4. The span method returns a pair. Show how you can get at each of the elements in that pair.

Step 2: Folding

1. Use the /: folding operator to concatenate all strings in a List[String], separating them with spaces. For example, if you start with val lst = List("Hello", "Scala", "World"), you should produce an expression involving lst and /: that yields "Hello Scala World". (Hint: It is very easy to get " Hello Scala World". The challenge is to get rid of the first space.
2. Folding is useful for much more than computing sums and products. Many algorithms that compute a value by making a loop through an array can be obtained with a suitable function whose first argument is the result from the elements that you have seen so far, and whose second argument is the next list element.

   Consider the case of computing the maximum. Find a suitable function whose first argument is the maximum of all elements visited so far, and whose second argument is the next element.

   What the code for your function maximum(lst : List[Int]) : Int? (You may assume that the list has length > 0)

3. What does this function do?

   def mystery(lst : List[Int]) = 
     (List[Int]() /: lst) ((x, y) => if (y % 2 == 0) x else x :+ y)

   Explain how the function works.

Step 3. A Puzzle

Here is a puzzle from a programmer web site:

Given an array of numbers, return the occurances [sic] of the number 1 in the array. So, if the array contains 1, 2, 11, 13 you would return 4 (as 11 contains two instances of 1). 

1. Suppose you are given a list of numbers, such as List(1, 2, 11, 13). To get digits of one, it would be better to have strings. How do you get an array of strings? Hint: toString, map
2. Now look at an individual string such as "1811". How can one count the number of ones? Hint: (1) Strings are collections of characters (2) Try the count method that takes a predicate. For example, (1 to 10).count(_ % 3 == 0) yields 3
3. Ok, now you need to apply that to each of the strings. How do you do that? (Hint: map)
4. That gives you a collection of counts. How do you total them up? Hint: reduce, or, if you prefer, look at the scaladoc of Seq for a simpler way.)
5. Now all together. If lst is a list of integers, how do you get the total number of digits of one?

Step 4: Misery with Tuples

1. What is 1 -> 2 -> 3? What is the type of the result?
2. Write a function flatten that takes such a thing and turns it into an (Int, Int, Int). Use _1, _2
3. Repeat with destructuring.
4. What is the result of the following statement, and why?

   val x,y,z = (1,2,3)

Step 5: If I Had Just One Data Structure...

1. And if I could just take one method, it would be groupBy. Load all words from a dictionary into a list by calling

   val words = io.Source.fromURL("http://horstmann.com/sjsu/spring2018/cs152/words").getLines.toList
   

   What is words.groupBy(w => w.length)?
2. Make a map so that myMap('a') yields all words that start with the letter a and so on.
3. How many words start with a given letter? Hint: myMap.map(...)
4. Extra credit: Turn this into a list of tuples that is sorted by frequency. Hint: sorted doesn't work because Scala doesn't know how to sort the tuples. There are two other sort methods. One of them wants a function that maps into something that Scala does know how to sort—the easy choice for solving this exercise.
5. Extra credit: Now do it with the other method (and some tuple misery).