1. Haskell
Chapter 4

2. Recursion Like other languages
Base case
Recursive call
Author programs a number of built-in functions as examples
Quick:
maximum [3,5,4] => 5 What’s the base case?
replicate 4 3 => [3,3,3,3] What’s the base case?
take 3 [1..10] => [1,2,3] What’s the base case?
take 5 [1..3] => [1,2,3] What’s the base case?

3. Maximum – Recursion w/ pattern matching
maximum' :: (Ord a) => [a] -> a maximum' [] = error "can't take maximum of empty list“ -- base case, if only one item, return it maximum' [x] = x -- else return max of first element or recursive call maximum' (x:xs) = max x (maximum' xs)

4. Replicate – Recursion w/ guards
replicate' :: Int -> a -> [a]
replicate' n x
-- base case returns empty list
| n <= 0 = []
-- else cons element to result of recursive call
| otherwise = x : replicate' (n-1) x
Used guards because boolean condition, not a pattern
replicate' 3 5
5 : replicate’ 2 5 => [5,5,5]
5 : replicate’ 1 5 => [5, 5]
5: replicate’ 0 5 => [5]
n == 0, => []

5. Take – Recursion w/ guard + patterns
Two base cases (n=0, or empty list)
Guard without otherwise will fall through to patterns
take' :: (Num i, Ord i) => i -> [a] -> [a]
take' n _
| n <= 0 = []
take' _ [] = []
take' n (x:xs) = x : take' (n-1) xs
Quick trace – (turn in)
take' 20 [1..4]
take' 3 [1..4]

6. Reverse Note ++ rather than : because both are lists
: works at front of list, not back
reverse' :: [a] -> [a]
reverse' [] = []
reverse' (x:xs) = reverse' xs ++ [x]
Quick trace (turn in)
reverse' [1, 2, 3, 4]

7. Repeat Haskell supports infinite lists repeat' :: a -> [a]
repeat' x = x:repeat' x
repeat 3
3: repeat 3
etc,
Don’t bother tracing, we don’t have all day. 

8. Think it through – don’t look ahead!
Prelude> zip [1,2,3] [4,5,6]
[(1,4),(2,5),(3,6)]
How would you write zip?
How many base cases?
What’s the recursive call?
Patterns or guards?
give patterns a try!
Add to your class participation

9. Zip
zip' :: [a] -> [b] -> [(a,b)] zip' _ [] = [] zip' [] _ = [] zip' (x:xs) (y:ys) = (x,y):zip' xs ys

10. Quick Exercise
With a partner, trace this code with this list of numbers:
[5,2,6,7,1,3,9,4]
quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
let
smallerOrEqual = [a | a <- xs, a <= x]
larger = [a | a <- xs, a > x]
in quicksort smallerOrEqual ++ [x] ++ quicksort larger
Add to your class participation

11. Play and Share?
No, let’s start on the homework.