Oct 8, 2003
-------------

- More on ML: topics covered today
	- code for mergesort
	- function composition
		- our own operator
		- ML's infix operator
	- currying, partial evaluation
	- use of map (a higher order function)

fun split(nil) = (nil,nil)
|   split([a]) = (nil,[a])
|   split(x::y::excess) =
   let
     val (l,r) = split(excess)
   in
     (x::l,y::r)
   end;

fun merge(nil,a)   = a
|   merge(a,nil)   = a
|   merge(L1 as x::xs, L2 as y::ys) =
  if (x<y) then x::merge(xs,L2)
           else y::merge(L1,ys);

fun mergesort(nil) = nil
|   mergesort([a]) = [a]
|   mergesort(L) =
   let
     val (left,right) = split(L);
     val sortedleft = mergesort(left);
     val sortedright = mergesort(right);
   in
     merge(sortedleft,sortedright)
   end;

fun comp(F,G) =
        let
           fun C(x) = F(G(x))
        in
           C
        end;

fun f1(x) = x+2;
fun f2(x) = x+3;
val addfive = comp(f1,f2);
val newaddfive = f1 o f2;
val newaddfive = (op o)(f1, f2);

fun power(x,0) = 1
|   power(x,n) = x * power(x,n-1);

fun power x 0  = 1
|   power x n  = x * power x (n-1);

(* difference is the latter can be curried *)

val threepower = power 3;

threepower 4;

fun squaring(x) = power x 2;

squaring(3);

fun square(x) = x*x;
val squarealist = map square;

squarealist([1,3,4]);

map square [1,3,4]; (* works *)
map(square,[1,3,4]); (* doesn't work, why? *)