Fun With the Scala Library

Using the Scala Documentation
Categories of List methods
Key operators and methods
The Pair class
Lab: Putting the library to work

Scala Documentation

Online at http://scala-lang.org/
Be smart: Download and install it locally
Be smart: Bookmark it
Like javadoc
Two flavors, scaladoc and vscaladoc (prettier)
As in Javadoc, don't forget to look at supertypes

Categories of `List` Methods

Basic methods length head tail isEmpty
Operators :: ::: + - -- == != < <= > >=
Access by position (n) take drop dropRight slice indexOf lastIndexOf
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 foldLeftfoldRight /: :\
Other intersection union zip zipAll zipWithIndex mkString

Operators

Function names can be any sequence of opchars: characters other than whitespace, A-Z0-9()[]{}`'".,;
Operators ending in : are right associative; all others are left associative
```
a :: b :: Nil is a :: (b :: Nil)
```
All operators have the same precedence. If in doubt, use ().

List(1, 2) ::: List(3, 4) is List(1, 2, 3, 4) // same as ++
List(1, 2) < List(3) is true // lexicographic order
List(1, 2, 3, 4) -- List(1, 3) is List(2, 4)

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 (with index values like in Java's String.substring)
```
List(2, 3, 5, 7).slice(1, 3) is List(3, 5) 
```
See lab for drop take

Methods with Function Parameters

Workhorse functions of the library
You already saw filter
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))

Function can be shortened—see next lecture
Predicate = function returning Boolean

Some methods return a pair

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

Tuples

A pair is an example of a tuple
If S, T, U are any types, then we have tuple types (S, T), (S, T, U)
Ex. ("Hello", 1729) is an instance of (String, Int)
Use methods _1 _2 etc. to access members (not zero-based!)
```
("Hello", 1729)._2 is 1729
```
Convenient if a method returns more than one piece of information
Don't use tuples if the data has semantics. Ex. Don't use (day, month, year). Make (or use) a Date class.

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

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

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

Work with a buddy
One of you fusses with the code, the other types up answers
Switch roles each time
Submit lab work to eCampus.

Step 1: Operators

What does the - operator do? Look it up in Scaladoc. Run a couple of experiments. What happens if a value occurs more than once in the list? Tell me which experiments you ran, and what you concluded.
In Java, == only checks for object identity. For example, String a = "Hel"; System.out.println(a + "lo" == "Hello") prints false. (You need to use equals to test for structural equality.) What is the situation for == with Scala lists? Tell me which experiments you ran, and what you concluded.

Step 2: Drop and Take

What do take and drop do? Give a brief explanation and an example for each.
What is the difference between take and dropRight?

Step 3: Predicates and Tuples

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?
The span method returns a pair. Show how you can get at each of the elements in that pair.

Step 4: Folding

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.
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)

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 5: Explore On Your Own

Of the other functions in slide 3, pick one that sounds interesting. Read the scaladoc. Make an example or two, and tell me what they are. Explain in your own words what the function does.