Review

Case class = class with constructor; constructor parameters become properties
Pattern matching: match against case subclass
Properties of matching object are bound to variables

Use: Recursive data structures (lists, trees, etc.)

abstract class List
case class Nil extends List
case class  Cons(Int head, List tail)

Warm-up exercise: In C/C++, we have primitive types (int, double, char, etc.) and derived types (pointer to T, array of T) such as int* or int[10]. Model this with three case classes that extend a common superclass Type

http://ActiveLecture.org

First-Class Functions

Java: values are either primitive types (int, double, char, etc.) or reference types (objects, arrays)

Scala: functions are also values

def fac(n : Int) : Int = if (n == 0) 1 else n * fac(n - 1)
fac: (Int)Int

val c = fac _
c: (Int) => Int = <function>

Minor subtlety: (Int)Int vs. (Int) => Int. When you work with functions, you always use the =>
Minor subtlety: fac must either be followed by an argument (to make an Int) or by an _ (to make an (Int) => Int)

Higher-Order Functions

Want to print table of function values

1 -> 1
2 -> 2
3 -> 6
4 -> 24
5 -> 120
 ...
10 -> 3628800

Need three parameters:
- from (1)
- to (10)
- the function (fac)
```
def table(from: Int, to : Int, f : (Int) => Int)
```

Higher-Order Functions

def table(from : int, to : Int, f : (Int) => Int) {
   var i = from;
   while (i <= to) {
      println(i + " -> " + f(i))
      i += 1
   }
}
table: (Int,Int,(Int) => Int)Unit

Call as
```
table(1, 10, fac _)
```
A “higher order” function because one of its parameters is a function
Can also have function return values
Functions are “first-class” values

Anonymous Functions

We use “literal” or “anonymous” values all the time
```
y = 2 * x + 1
```
Without anonymous values, it would be
```
val a = 2
val b = 1
y = a * x + b
```
Also have string literals "Hello"
In a functional language, where functions are values, there is no need to name every function
```
table(10, (x : Int) => x * x)
```
Same as
```
def sq(x : Int) = x * x
table(10, sq _)
```

Constructing Functions

Anonymous functions are useful to make functions “on the fly”
Example: Want to protect a function so that fac(-1) or sqrt(-1) doesn't blow up
Want protect(f)(x) = if (x >= 0) f(x) else 0
Not that simple. protect takes a function and produces a function
```
def protect(f : (Int) => Int) : (Int) => Int = result
```
What is the result? Easy in lambda calculus:
```
λ x . if (x >= 0) f(x) else 0
```
In Scala, use x : Type => body instead of λ x . body
```
(x : Int) => if (x >= 0) f(x) else 0
```

def protect(f : (Int) => Int) = (x : Int) => if (x >= 0) f(x) else 0
protect: ((Int) => Int)(Int) => Int

table(-3, 3 ,protect(fac _))
-3 -> 0
-2 -> 0
-1 -> 0
0 -> 1
1 -> 1
2 -> 2
3 -> 6

API Implications

In a functional language, many APIs use functions instead of interfaces

Some methods of the Scala List[A] class

count(p : (A) => Boolean) : Int
filter(p : (A) => Boolean) : List[A]
map(f: (A) => B) : List[B]

Ex. Count all short strings in a list

val lst = List("Mary", "had", "a", "little", "lamb")
val cnt = lst.count((s : String) => s.length <= 3)

In this case, parameter type can be inferred:
```
val cnt = lst.count((s) => s.length <= 3)
```
Can leave off () around single parameter:
```
val cnt = lst.count(s => s.length <= 3)
```
Can use wildcard parameter _ if it is only used once:
```
val cnt = lst.count(_.length <= 3)
```

This is much easier on the eyes than the Java analog

int cnt = 0;
for (String s : lst)
   if (s.length() <= 3) cnt++;

Lab

Lab instructions in eCampus
Submit to eCampus, buddy name in comment field
If you don't have an eCampus login yet, go to http://horstmann.com/sjsu/cs252/lab6.html
Any weird problems? Use the Ask feature in http://ActiveLecture.org and make a screen capture.