CS 152 - Lecture 2

Cover page image

Functional Programming

Functional programming: Functions are values
In Java, values are
- Primitive types int, double, etc.
- References to objects or arrays
A method is not a “first class” value in Java
- Cannot declare a variable that holds a method
- Cannot create new method in a running program
In a functional programming language, functions are first-class values
- Can have variables that hold functions
- Can create new functions

Functions can be values

val num = 3.14
val fun = math.ceil _
fun(num) // prints 4

Functions can be anonymous...
```
(x : Int) => x * x
```
...just like numbers
```
3.14
```
Of course, can put function values into variables and then use them
```
val square = (x : Int) => x * x
square(10) // prints 100
```
...again, just like numbers
```
val pi = 3.14
pi * 10 // prints 31.4
```

Often useful to pass functions as parameters

val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
numbers.map((x : Int) => x * x)
   // Yields a new List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

You can pass behavior as an interface:

public static <T> List<R> map(List<T> values, Transformer<T, R> f)

Java 8 lambdas provide syntactic sugar, but they are not true functions.
Functions have been with us for hundreds of years of mathematics.
Making them “first class citizens” in a programming language provides expressive power.

Variable type is inferred:

val luckyNumber = 13 // luckyNumber is an Int

Function types:

val square = (x : Int) => x * x // square is an Int => Int

Semicolons at the end of a line are optional

val x = 1
val y = 2 + // end line with operator to indicate that there is more to come
3

Immutable: Cannot change
In Java, strings are immutable
- "Hello".toUpper doesn't change "Hello" but returns a new string "HELLO"
In Scala, val are immutable
```
val num = 3.14
num = 1.42 // Error
```
Pure functional programming: No mutations
If you call a function twice with the same inputs, you know you'll get the same result
Functions that don't mutate state are inherently parallelizable
Important consideration in light of the end of Moore's Law

if (booleanExpression) expression1 else expression2

if/else is an expression, not a statement. Can be used in other expressions:
```
val x = (if (true) 2 else 4) * 3
```
Like ? : in Java
Type is the most specific supertype common to expression1, expression2
```
val x = if (true) 3 else "Hello" // type is AnyVal
```
Omitting the else yields type Unit (like void in Java); not useful in functional programming

def syntax for functions

def triple(x : Int) = 3 * x
// same as val triple = (x : Int) => 3 * x

With recursive functions, also need to specify return type:

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

Need def because the name is used on the right

val fac = (x : Int) => if (x == 0) 1 else x * fac(x - 1) // fac not defined yet

Iteration (while, for) can always be expressed as recursion

To iterate is human; to recurse, divine (L. Peter Deutsch)

Format of classes: approx. 20 minutes lecture, 45 minutes lab, 10 minute wrap-up
You work with a buddy
One of you (the coder) writes the code, the other (the scribe) types up answers
When you get stuck, ask your buddy first!
Switch coder/scribe roles each lab
The scribe submits lab work in lab1/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.

Start Eclipse and make a new Scala project: File -> New -> Project -> Scala Project. Give a name lab1 and click Finish. Right-click on the project in the Package Explorer, then select New -> Scala worksheet. Call it sheet1.
Type 39+3 and save the worksheet. What do you get?
Type val a = 39 + 3. What do you get?
Type a + 1. What do you get?
Type a = 9. What do you get? Why?
Type val b; (This time with a semicolon.) What do you get? Why?

Type val triple = (x : Int) => 3 * x. What do you get?
Type triple(5). What do you get?

HINT: These “What do you get” exercises are a lot more effective when you and your buddy first discuss what you think you'll get. “Form a hypothesis” is an essential part of the learning path.
Type triple. What do you get?
What is the type of triple in Scala?
What is the type of 5 in Scala?

Type List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10). What do you get?
Type List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).map(triple). What do you get? Why?
How do you get the cubes of the numbers from 1 to 10 without using val or def? Hint: Anonymous function.

Your task is to write a function sevens(n: Int): Int that counts how many digits of n are the digit 7. For example, sevens(747) returns 2. How would you do this in Java (without converting the number to a string)?
In functional programming, you can't increment a counter. But you can use recursion. How can you compute the answer recursively? Hint: If n is 0, you know the answer. Otherwise, in plain English or pseudocode, how can you compute the answer from n % 10 and sevens(n / 10)?
What's your code in Scala?