(* Type Inference *)
(* simulate type checker (in a way) *)
(* this is given: abs: int -> int *)
fun f x =
let val (y,z) = x in
(abs y) + z end
(*
f: T1 -> T2 x: T1
y: T3
z: T4
T1 = T3*T4
T3 = int T4 = int T2 = int
f: int*int -> int x: int
*)
fun sum xs = case xs of
[] => 0
| x::xs' => x + (sum xs')
(*
sum: T1 -> T2 xs: T1
T1 = T3 list
T2 = int
xs': T1 = T3 list x: T3
T3 = T2 = int
sum: int list -> T2 *)
fun broken_sum xs = case xs of
[] => 0
| x::xs' => x + (broken_sum x)
(*
broken_sum: T1 -> T2 xs: T1
T1 = T3 list T2 = int
xs': T3 list x: T3
T3 = T2 = int T3 = T3 list
*)
fun length xs = case xs of
] => 0
| x::xs' => 1 + (length xs')
(*
length: T1 -> T2 xs: T1
T1 = T3 list
T2 = int
xs': T3 list (=T1) x: T3
length: 'a list -> int
xs: 'a list *)
fun f (x,y,z) = if true
then (x,y,z)
else (y,x,z) (*
f: T1 * T2 * T3 -> T4 x: T1,
y: T2,
z: T3,
T1 = T2
T4 = T1*T1*T3
f: 'a * 'a * 'b -> 'a * 'a * 'b T1*T1*T3 ->
T1*T2*T3
*)
fun compose (f,g) = fn x => f (g x)
(* compose: T1 * T2 -> T3 f: T1
g: T2
anon func: T3 = T4 -> T5
x: T4
g: T1= T4-> T6 f: T2= T6-> T5
compose: T6->T5 * T4->T6 -> T4->T5 'a->'b *
'c->'a -> 'c->'b
*)
signature RATIONAL_A = sig
datatype rational = Frac of int * int | Whole of int exception BadFrac
val make_frac : int * int -> rational
val add : rational * rational -> rational
val toString : rational -> string end
structure Rational1 :> RATIONAL_A = struct
(* Invariant 1: all denominators > 0
Invariant 2: rationals kept in reduced form *)
datatype rational = Whole of int | Frac of int*int exception BadFrac
(* gcd and reduce help keep fractions reduced, but clients need not know about them *)
(* they _assume_ their inputs are not negative *) fun gcd (x,y) =
if x=y
then x
else if x < y then gcd(x,y-x) else gcd(y,x)
(* Frac(5, 10) ==> Frac(1, 2) Frac(10, 5) ==> Whole(2) *)
fun reduce r = case r of
Whole _ => r | Frac(x,y) =>
if x=0
then Whole(0)
else let val d = gcd(abs x, y) (* using invariant 1 *) in
if y=d
then Whole(x div d)
else Frac(x div d, y div d)
end
(* when making a frac, we ban zero denominators *) fun make_frac (x,y) =
(* enforce invariant 1 (denom > 0) *) (* must handle div by zero *)
if y=0
then raise BadFrac
else if y < 0
then reduce Frac(~x, ~y) else reduce Frac(x, y)
(* using math properties, both invariants hold of the result assuming they hold of the arguments *)
fun add (r1,r2) =
case (r1,r2) of
(Whole(i),Whole(j)) => Whole(i+j)
| (Whole(i),Frac(j,k)) => (*i+j/k ==> (i*k+j)/k *) Frac(i*k+j, k)
| (Frac(j,k),Whole(i)) => Frac(i*k+j, k)
| (Frac(a,b),Frac(c,d)) => (* a/b+c/d = (a*d+c*b)/bd *)
reduce Frac(a*d+c*b, b*d)
(* given invariant, prints in reduced form *) fun toString r =
case r of
Whole i => Int.toString i (* 1=>"1", 2=>"2" *)
| Frac(a,b) => (Int.toString a) ^ "/" ^ (Int.toString b) (*1/2 ==> "1/2" *)
end
fun count_multiples (x, nums_list) = let val multiples =
filter(fn num => num mod x = 0, nums_list) in
map(List.length, multiples) end
(* similar to above, given x, count the multiples of x in each list * and returns the index of the list having the
maximum count. * x=11, [[1, 2, 11], [11, 22, 33], [4, 5]]
*==> 1 *)
(* 1. call count_multiples above
* 2. apply fold. acc = (max_index, curr_index, max_value)
* hint: keep acc tuple containing (index of current max, current index, max multiples)
* e.g. x=11, [[1, 2, 11], [11, 22, 33], [4, 5], [11, 22, 33, 44]]
* * * *)
[1, 3, 0, 4]
(0, 0, 1) ==> (1, 1, 3) ==> (1, 2, 3) ==> (3, 3, 4)
(0, 1, 1) (1, 2, 3)
fun index_of_max_multiple_count (x, nums_list) = let val counts = count_multiples(x, nums_list)
(* in
[1, 3, 3] *)
fold(fn acc, numMults => if (#3 acc) < numMults
then (#2 acc, 1+(#2 acc), numMults)
(0, 0, hd(counts)),
counts) end
fold(fn acc, y => if #maxVal acc > y then
{maxIdx=#maxIdx acc, currIdx=1+(#currIdx acc), maxVal=#maxVal acc}
else
{maxIdx=#currIdx acc,
currIdx=1+(#currIdx acc),
maxVal=y}
{maxIdx=0, currIdx=0, maxVal=hd(counts)},
counts)
(* {maxIdx:int, currIdx:int,
fun map (f, xs) =
case xs of [] => []
| x::xs' => f(x)::map(f, xs')
fun filter(f, xs) = case xs of
[] => []
| x::xs' => if f x then x::filter(f, xs')
else filter(f, xs')
(* foldl *)
fun fold(f, acc, xs) =
case xs of [] => acc
| x::xs' => fold(f, (f(acc,x)), xs') (* use fold to find max in a list *)
val ints = [1,9,5,1]
val mymax = fold (fn (acc, x) => if x>acc then x else acc,
hd(ints), ints)
val nums_list = [[9, 40, 75, 7], [64, 34, 88, 96],
[91, 92, 53, 31], [50, 84, 73, 65], [54, 44, 75, 11], [91, 71, 48, 46],
[70, 72, 5, 42], [25, 77, 49, 56],
[89, 4, 73, 52],
[36, 56, 61, 1]] (* fun fold(f, acc, xs) *)
(* let's find local max by applying fold to each list *)
val local_max = map(fn nums => fold(fn (acc, x) => if x>acc then x else acc,
hd(nums), nums), nums_list)
(* [75, 96, ... ] *)
(* now apply fold again! *)
val global_max = fold (fn (acc, x) => if x>acc then x else acc,
hd(local_max), local_max)
XXX:
(* similar to above, given x, count the multiples of x in each list
* and returns the index of the list having the maximum count. *
* x=11, [[1, 2, 11], [11, 22, 33], [4, 5]]
*==> 1*)
(* 1. call count_m ultiples above
* 2. apply fold. acc = (max_index, curr_index, max_value)
* hint: keep acc tuple containing (index of current max, current index,
max multiples)
* e.g. x=11, [[1, 2, 11], [11, 22, 33], [4, 5], [11, 22, 33, 44]] * (0, 0, 1) ==> (1, 1,
3)
fun index_of_max_multiple_count (x, nums_list) = let val counts =
(* [1, 3, 3] *)
in fold(
(0, 0, hd(counts)), …………..counts) end
(* abstract data type using closures *)
(* int set
* with 3 methods: insert, member, size,
* notice insert returns a set (a new set) *)
datatype set = S of { insert : int -> set, member : int -> bool,
size : unit -> int }
(* implementation of sets: this is the fancy stuff, but client
s using this abstraction do not need to understand it *)
val empty_set = let
fun make_set xs =
let fun contains i = List.exists (fn j => i=j) xs in
S({ insert = fn i => if contains i then make_set xs
else make_set i::xs, member = contains,
size = fn () => List.length xs })
end
in ………… make_set [] (* set value S{...}*) ………….end
(* example client *)
val S(s1) = empty_set;
val S s2 = (#insert s1) 34; (* s2 has xs=[34] *) val S s3 = (#insert s2)
34; (* s3 xs=[34] *) valSs4=#inserts319; (*s4xs=[34,19]*)
val pairWithOne = List.map (fn x => (x,1)) (* warning !!! *) (* example *)
(* tupled but we wish it were curried *)
(* range(1, 3) ==> [1,2] *)
fun range (i,j) = if i > j
then []
else i :: range(i+1, j)
(* function counting from 1 *) val count_upto = curry range 1
fun count_upto2 to = range(1, to)
(* xs = [1, 2, ..., 7] *) val xs = count_upto 7
(* count10from 7 ==> [7, 8, 9, 10] *)
val count10from = other_curry1 (curry range) 10
(* workarounds: *) fun pairWithOne xs =
List.map (fn x => (x,1)) xs
val pairWithOne : string list -> (string * int) list = List.map (fn x => (x,1))
