1. Functional Programming Lecture 2 - Functions
Muffy Calder

2. Function Definitions f :: Int -> Int -- multiply argument by 100
f x = x*100
“f takes an Int and returns an Int; the value of f x is x*100”
The mantra: comment, type, equation

3. Defining Equation of Function
Fn_name arg1 arg2 … argn
= expression that can use
arg1…argn
E.g. g x y = x + y >= 10

4. Evaluation or Simplification
Given:
f x y = x*y
Evaluate: f 3 4
f 3 4 => 3 * 4 = 12
Now evaluate: f 3 (f 4 5)
f 3 (f 4 5) => 3 * f 4 5 => 3 * (4*5) => 3 * 20 => 60
Note there is an alternative evaluation!
Does it matter which one we pick? (Stay tuned)

5. Programs (Scripts) What is meant by “given”?
A set of definitions is saved in a file.
E.g.
x = 2
y = 4
z = 100*x -30*y
f :: Int -> Int -> Int
f x y = x + 2*y
You use a program by “asking” it to perform a calculation, e.g. calculate f 2 3.
> f 2 3

6. Equations vs. Assignments
Assignment - command to update a variable
e.g. x:= x+1
x   3
Equation - permanent assertion that two values are equal e.g. x=3 or x = y+1
x ----- 3
You obey assignments and solve equations.
Equations in a script can appear in any order!

7. := and = Ada x := x+1 take the old value of x and increment it
This is a common and useful operation.
Haskell x = x+1
Assert that x and x+1 are the same value.
This equation has no solution.
It is a syntactically-valid statement, but it is not solvable. There is no solution for x. So this equation cannot be true!

8. Side Effects and Equational Reasoning
Equations are timeless - there is no notion of changing the value of a variable
Mathematics (algebra) is all about reasoning with equations, not with the contents of computer locations -- that keep changing.

9. Local names: let expressions
let x = 1
y = 2
z = 3
in x+y+z
The variables x, y, z are local
A script is just one big let expression.

10. A let expression is an expression!
E.g.
2 + let a = x+y in (a+1)*(a-1)
2 + (let a = 5 in (a+1)*(a-1) ) + 3
- allows you to make some local definitions
- it is not a block of statements to be executed.

11. Conditional expressions
if boolean_exp
then exp1 else exp2
Haskell evaluates boolean_exp and returns the appropriate expression.
exp1 and exp2 must have the same type
E.g.
f x = if x>3 then x+2 else x-2
g x = if x>3 then x+2 else False (wrong)
What are the types of f and g?

12. Guarded expressions f x | x>0 = True | otherwise = False
In general:
Name x1 x2 .. xn
| guard = e1
| guard = e2 ….
| otherwise = e
Haskell evaluates the guards, from the top, and returns the appropriate expression.
guard1, ... must have the Bool type
exp1, ... must have the same type
Note:
| otherwise = (wrong)

13. Examples positive :: Int -> Bool positive x | (x>=0) = True
| otherwise = False or
positive x = if (x>=0) then True else False
max :: Int -> Int -> Int
max x y
| (x>=y) = x
| otherwise = y
max x y = if (x>=y) then x else y
maxthree :: Int -> Int -> Int -> Int
maxthree x y z
| ((x>=y) && (x>=z) = x
| (y>=z) = y
| otherwise = z

14. Examples or maxthree x y z = max x (max y z)
mystery :: Int -> Int -> Int -> Bool
mystery m n p = not ((m==n) && (n==p))
Evaluate:
mystery 0 1 2
mystery 0 1 1
mystery 1 1 1

15. Recursion
Functions can be recursive (i.e. the function can occur on the rhs of the defining equation).
This is fundamental to functional programming.
Example
fact :: Int -> Int
fact 1 = fact.0
fact n = n * (fact n-1) fact.1
So, fact 4 => 4 * (fact 3)
=> 4 * 3 * (fact 2)
=> 4 * 3 * 2 * (fact 1)
=> 4 * 3 * 2 * 1
=> 24
fact.0 is called the base case.

16. Off-side Rule mystery :: Int -> Int -> Int -> Bool
mystery m n p = not ((m==n) && (n==p))
the box
Whatever is typed in the box is part of the definition.
So,
f :: Int -> Int
f x = okay
g :: Int -> Int (start new definition)
g x okay
= 36
h:: Int -> Int
h y= 42 * okay 1
hy =
will give an error (unexpected ‘;’)

17. Functional Data Structures
Allow you to build aggregate objects from smaller values
Built-in data structures
Lists
Tuples
Arrays
User defined data structures