### CS52 - Fall 2015 - Class 5

#### Example code in this lecture

map-examples.sml
better_factorial.sml
lets_count.sml
subtraction.sml

#### Lecture notes

• admin
- assignment 2 due Friday at 5pm
- mentor feedback

• some debugging advice
- test individual parts as much as possible

- test recursive case manually
- look at combList solution
- consider combList 2 [1, 2, 3]
- how could you check to see if you're recursive case is correct even without the base cases?
- combList (m-1) xs = combList 1 [2,3] = [[2], [3]]
- combList m xs = combList 2 [2,3] = [[2,3]]
- (consAllk 1 [[2], [3]]) @ [[2,3]];
val it = [[1,2],[1,3],[2,3]] : int list list
- If this doesn't work right, then you know the recursive case isn't correct!
- If it does work right, then you can be more confident that your recursive case is correct
- just need to narrow down the problem with the base case(s)

- What is the "_" variable in the solution?
- It's just like putting x, y, a, b, etc.
- But, it's a way of communicating to anyone reading the code that the variable doesn't matter!
- notice that the variable isn't used anywhere on the right hand side
- try and use this in your code

• time saver: op
- look at the calcAreas example from last time (map-examples.sml code)
- What would be another name for the area function, i.e. what does it do?
- multiply

- seems a waste to define a new function where there is already a multiply operator (*)
- can we just write:

fun calcAreas lst = map * lst;

- No!
- this just tries to multiply map by lst
- * is an infix operator that expects its arguments to be on either side

- op helps us in this situation
- op takes an operator as input and returns a prefix function (i.e. normal) where the input parameters are pass as a tuple:

x ? y -> ? (x, y)

- For example:
> op*;
val it = fn : int * int -> int

- Does this help us with calcAreas?

> fun calcAreas lst = map op* lst;
val calcAreas = fn : (int * int) list -> int list

- Note this works for all the operators (we'll see more use for this later)
> op/;
val it = fn : real * real -> real
> op div;
val it = fn : int * int -> int
> op::;
val it = fn : 'a * 'a list -> 'a list
> op@;
val it = fn : 'a list * 'a list -> 'a list

• a better factorial
- factorial is a function that should only be called on non-negative numbers
- look at the badFactorial function in better_factorial.sml code
- hopefully your code looked something like this
- here I've had it return 0 for any negative number
- this avoids the infinite recursion
- but still isn't very satisfying
- what's a better approach?
- throw/raise an exception!

• exceptions in SML
- You can define a new exception in SML by adding:
exception <name_of_exception>;

- By convention, the name of the exception will be capitalized
- You can then "raise" an exception anywhere in the code by adding:
raise <name_of_exception>

- look at the factorial function in better_factorial.sml code
- we declared an exception called NegativeNumber
- in the case where someone passes a number less than 0 we raise the exception

> factorial 4;
val it = 24 : int
> factorial ~4;

uncaught exception NegativeNumber
raised at: better_factorial.sml:13.15-13.29

- I'll talk in a couple of weeks about handling exceptions (aka catching exceptions)

• let (count example)
- write a function called "count":
- takes two parameter
- a value
- a list of values
- returns a tuple containing how many times that value occurs in the list as the first element AND the list with all occurrences of the item removed as the second element
- We could fairly easily write this as three function (one helper function for each value and a third to put it all together)
- I want to write it as a single recursive function.

1. function header
val count = fn: 'a -> 'a list -> (int * 'a list)

2. recursive case
- will we be recursing on the list on the number?
- list
- assume the recursive call works, what would it give us back?
- count a (x::xs) = ??? (count a xs)
- (count a xs)
- how many times a occurs in xs
- xs with all occurrence of a removed
- as a tuple
- if we had this information, what would we need to do?
- just check a against x
- if it's equal
- add 1 to the number of occurrences
- don't include x
- it it's not equal
- keep the number of occurrences the same
- include x
- how can we write this?
if a = x then
(count a xs) ???
- since count returns a tuple, we need a way to get at the values of the tuple
- two ways
- less elegant way: #1
- there are functions #1, #2, ... that get at elements in a tuple
> #1 (10, 20)
val it = 10 : int
> #2 (10, 20);
val it = 20 : int
- a better way
- we can use a let statement to unpack a tuple (or many other types of values!)
- look at the count function in lets_count.sml code
- we declare a new value in the let statement that is a tuple and call the recursive case
- num will get the first value of the tuple and lst the second
- we have unpacked the tuple
- we can then use the values in the if statements below
- this technique works on any pattern type things, e.g.
let
val (x::xs) = some_call_that_returns_a_nonempty_list
in
(* use x and xs *)
end;

• bigger numbers in SML
- the largest integer we can represent in SML of type int is:
> Int.maxInt;
val it = SOME 1073741823 : int option

(* 1,073,741,823: a bit over a trillion *)
- what if we want numbers larger than that?
- reals partially solves the solution, although it also includes decimal values and it also has a maximum value
- a better solution is to make our representation for numbers that can get as large as we want
- ideas?
- represent numbers as a list of digits!
- lists can get as long as we'd like
- for logistic reasons, we're going to put the least significant digits at the *front* of the list and the most significant digits at the *back*
- for example:
- 5,432 in list form is [2, 3, 4, 5]
- 9,308,312 in list form is [2, 1, 3, 8, 0, 3, 9]

• subtraction
5421
-780
----

...

- swb: subtract with borrow helper function

1. header
- first parameter is the borrow bit: 0 or 1 (we could do with a bool if you'd like as well)
- second parameter is number being subtracted *from*
- third parameter is the number being subtracted

val swb = fn: int -> int list -> int list -> int list

2. recursive case
- what are we recursing over?
- both of the lists!

swb b (l::ls) (r::rs) = ??? (swb ? ls rs)

- we want to make a recursive case on the rest of the list like we did by hand
- we may need to borrow
- how do we figure this out?
- digit = l - b - r
- if this is greater than or equal to 0, we're fine
- don't need to borrow
- digit is our answer
- if this value is less than 0
- we need to borrow
- digit + 10 is our answer

3. base cases
- we're recursing over two lists. What are the possible base cases?
- there are three!
- both are empty at the same time
- left is empty
- right is empty
- let's start with the cases where only one is empty
- right is empty
swb b l [] = ?

- we could try and handle this with an if statement depending on b
- better to just let it get handled by the recursive case!
swb b l [0]

- this is equivalent to adding a 0 to the front of the number
- left is empty
- we can do the same thing!
swb b [0] r
- both empty
- here it will depend if there is a borrow bit
- if not, then we're done!
- if there is, then we've tried to borrow, but there's no numbers left
- the answer is negative!
- we'll talk about representing negative numbers next time
4. put it all together
- swb is really just a helper function. We don't want to have to specify the borrow bit every time we try and subtract two lists
- look at the subDigitList function in subtraction.sml code