datatype huffTree = Leaf of char * int  
                  | Internal of huffTree * huffTree * string * int;


fun weight(Leaf(sym, w)) = w
  | weight(Internal(left, right, sym, w)) = w;

fun symbols(Leaf(sym, w)) = str(sym)
  | symbols(Internal(left, right, sym, w)) = 
          symbols(left) ^ symbols(right);

fun makeTree(left, right) = 
     Internal(left, right, symbols(left) ^ symbols(right),
              weight(left) + weight(right));

fun printTree(Leaf(sym, w)) = print("Leaf(\"" ^ str(sym) ^ "\", " 
                                    ^ Int.toString(w) ^ ")")
  | printTree(Internal(left, right, syms, w)) =
                (print("makeTree("); printTree(left); print(", ");
                 printTree(right); print(")"));

val namePairs = [(#"A", 4), (#"C", 1), (#"D", 1), (#"E", 2),
                 (#"G", 1), (#"I", 1), (#"K", 1), (#"N", 5),
                 (#"R", 2), (#"U", 1), (#"V", 1), (#" ", 2)];


fun makeLeafSetNaive([]) = []
  | makeLeafSetNaive((sym, freq)::morePairs) =
     Leaf(sym, freq) :: makeLeafSetNaive(morePairs);


(* For exercise 6.3.1 *)

fun adjoinSet(x, []) = [x]
  | adjoinSet(x, fst::rest) =
     if weight(x) > weight(fst)
     then ??
     else ?? ;



fun makeLeafSet([]) = []
  | makeLeafSet((sym, freq)::morePairs) =
     adjoinSet(Leaf(sym, freq), makeLeafSet(morePairs));

fun oneMerge([x, y]) = ([], makeTree(x, y))
  | oneMerge(x::rest) = 
      let val (others, node) = oneMerge(rest) in (x::others, node) end;
                                       

(* For exercise 6.3.2 *)

fun successiveMerge([x]) = x 
  | successiveMerge(nodes) = ?? ;





fun generateHuffTree(pairs) = successiveMerge(makeLeafSet(pairs));

datatype bit = One | Zero;

fun printBit(One) = print("One")
  | printBit(Zero) = print("Zero");


(* For exercise 6.3.3 *)

fun encodeSymbol(sym, tree) = 
   let 
      fun encodeSymbol1(sy, Leaf(st, w)) = 
             ??
        | encodeSymbol1(sy, Internal(left, right, st, w)) =
             case (encodeSymbol1(sy, left), encodeSymbol1(sy, right)) of
                (NONE, NONE) => ??
              | (NONE, SOME bits) => ??
              | (SOME bits, x) => ?? ;
    in
      valOf(encodeSymbol1(sym,tree))
    end;



fun encodeList([], tree) = []
  | encodeList(fst::rest, tree) = 
       encodeSymbol(fst, tree)@encodeList(rest, tree);

fun encode(msg, tree) = encodeList(explode(msg), tree);


(* For exercise 6.3.4 *)

fun chooseBranch(Zero, Internal(left, right, s, w)) = left
  | chooseBranch(One, Internal(left, right, s, w)) = right;

fun decode(bits, tree) =
   let
      fun decode1([], currentBranch) = []
        | decode1(b::rest, currentBranch) =
           let val nextBranch = ??  in
           case nextBranch of
             Leaf(sym, w) => ?? 
           | Internal(left, right, syms, w) => ??
           end;
   in
     implode(decode1(bits, tree))
   end;