View difference between Paste ID: m7A7wGyN and zx4AQmY5

-datatype HuffmanTree =
+datatype HuffmanTree =
     Node of (string * int) * HuffmanTree * HuffmanTree
   | Symbol of char * int;
 
 local
-	fun unique [] = []
+    fun unique [] = []
     | unique (x::xs) = x:: unique (List.filter (fn y => y<>x) xs);
-	fun countLetterAux (x:string,a:char,i:int) = if i=size(x) then 0 else (if String.sub(x,i)=a then 1+countLetterAux(x,a,i+1) else countLetterAux(x,a,i+1));
+    fun countLetterAux (x:string,a:char,i:int) = if i=size(x) then 0 else (if String.sub(x,i)=a then 1+countLetterAux(x,a,i+1) else countLetterAux(x,a,i+1));
-	fun countLetter (x:string,a:char) = if size(x)=0 then 0 else countLetterAux(x,a,0);
+    fun countLetter (x:string,a:char) = if size(x)=0 then 0 else countLetterAux(x,a,0);
 
 in
-	fun computeHistogram "" = []
+    fun computeHistogram "" = []
-	|  computeHistogram s = map (fn x => (x,countLetter(s,x))) (unique(explode s))
+    |  computeHistogram s = map (fn x => (x,countLetter(s,x))) (unique(explode s))
 end;
 
 local
-	local
+    local
-		fun merge _ [] [] = []
+        fun merge _ [] [] = []
-			| merge _ list [] = list
+            | merge _ list [] = list
-			| merge _ [] list = list
+            | merge _ [] list = list
-			| merge pred (x::xs) (y::ys) = if pred(x,y) then (y::(merge pred (x::xs) ys))
+            | merge pred (x::xs) (y::ys) = if pred(x,y) then (y::(merge pred (x::xs) ys))
-													  else (x::(merge pred xs (y::ys)))
+                                                      else (x::(merge pred xs (y::ys)))
-	in
+    in
-		fun mergesort _ [] = []
+        fun mergesort _ [] = []
-			| mergesort _ [x] = [x]
+            | mergesort _ [x] = [x]
-			| mergesort pred l = merge pred
+            | mergesort pred l = merge pred
-				(mergesort pred (List.take (l,((length l) div 2))))
+                (mergesort pred (List.take (l,((length l) div 2))))
-				(mergesort pred (List.drop (l,((length l) div 2))))
+                (mergesort pred (List.drop (l,((length l) div 2))))
-	end;
+    end;
-	fun compareTuple ((x:string,n1),(y:string,n2)) = if n1=n2 then y<x else n2<n1
+    fun compareTuple ((x:string,n1),(y:string,n2)) = if n1=n2 then y<x else n2<n1
-	fun compareTuple2 ((x:char,n1),(y:char,n2)) = compareTuple((str(x),n1),(str(y),n2))
+    fun compareTuple2 ((x:char,n1),(y:char,n2)) = compareTuple((str(x),n1),(str(y),n2))
-	fun sortAndConvert lst = map (fn (x,n) => Symbol(x,n)) (mergesort compareTuple2 lst)
+    fun sortAndConvert lst = map (fn (x,n) => Symbol(x,n)) (mergesort compareTuple2 lst)
-	fun buildHuffmanTreeAux (Symbol(x,n1)::Symbol(y,n2)::_) = Node(((str(x)^str(y)),(n1+n2)),Symbol(x,n1),Symbol(y,n2))
+    fun buildHuffmanTreeAux (Symbol(x,n1)::Symbol(y,n2)::_) = Node(((str(x)^str(y)),(n1+n2)),Symbol(x,n1),Symbol(y,n2))
-	| buildHuffmanTreeAux (Node((s,n1),T1,T2)::Symbol(y,n2)::_) = if compareTuple((s,n1),(str(y),n2))
+    | buildHuffmanTreeAux (Node((s,n1),T1,T2)::Symbol(y,n2)::_) = if compareTuple((s,n1),(str(y),n2))
-						  then Node((str(y)^s,n1+n2),Symbol(y,n2),Node((s,n1),T1,T2))
+                          then Node((str(y)^s,n1+n2),Symbol(y,n2),Node((s,n1),T1,T2))
-						  else Node((s^str(y),n1+n2),Node((s,n1),T1,T2),Symbol(y,n2))
+                          else Node((s^str(y),n1+n2),Node((s,n1),T1,T2),Symbol(y,n2))
-	fun buildHuffmanList (x::[]) = x
+    fun buildHuffmanList (x::[]) = x
-	| buildHuffmanList lst = buildHuffmanList((buildHuffmanTreeAux (List.take(lst,2)))::(List.drop(lst,2)))
+    | buildHuffmanList lst = buildHuffmanList((buildHuffmanTreeAux (List.take(lst,2)))::(List.drop(lst,2)))
 in
-	fun buildHuffmanTree lst = buildHuffmanList (sortAndConvert lst)
+    fun buildHuffmanTree lst = buildHuffmanList (sortAndConvert lst)
 end;
 
 fun encodeMessage tree s =
 let
-	fun LetterEncodingHist (Symbol(x,n),s) = [(x,s)]
+    fun LetterEncodingHist (Symbol(x,n),s) = [(x,s)]
-	| LetterEncodingHist (Node(_,T1,T2),s) = (LetterEncodingHist (T1,s^"0"))@(LetterEncodingHist (T2,s^"1"))
+    | LetterEncodingHist (Node(_,T1,T2),s) = (LetterEncodingHist (T1,s^"0"))@(LetterEncodingHist (T2,s^"1"))
-	fun LetterEncoding ([],_) = ""
+    fun LetterEncoding ([],_) = ""
-	| LetterEncoding ((y,s)::lst,x) = if y=x then s else LetterEncoding (lst,x)
+    | LetterEncoding ((y,s)::lst,x) = if y=x then s else LetterEncoding (lst,x)
-	val hist = LetterEncodingHist(tree,"")
+    val hist = LetterEncodingHist(tree,"")
 in
-	foldr op^ "" (map (fn c => LetterEncoding(hist,c)) (explode s))
+    foldr op^ "" (map (fn c => LetterEncoding(hist,c)) (explode s))
 end;
 
 local
-	fun decodeMessageAux (Symbol(a,n)) _ [] = str(a)
+    fun decodeMessageAux (Symbol(a,n)) _ [] = str(a)
-	| 	decodeMessageAux (Symbol(a,n)) T2 lst = str(a)^(decodeMessageAux T2 T2 lst)
+    |   decodeMessageAux (Symbol(a,n)) T2 lst = str(a)^(decodeMessageAux T2 T2 lst)
-	| 	decodeMessageAux (Node((x,n),TL,TR)) T2 lst = if (hd lst) = #"0" then decodeMessageAux TL T2 (tl lst)
+    |   decodeMessageAux (Node((x,n),TL,TR)) T2 lst = if (hd lst) = #"0" then decodeMessageAux TL T2 (tl lst)
-													else decodeMessageAux TR T2 (tl lst)
+                                                    else decodeMessageAux TR T2 (tl lst)
 in
-	fun decodeMessage tree s = decodeMessageAux tree tree (explode s)
+    fun decodeMessage tree s = decodeMessageAux tree tree (explode s)
 end;
 
 fun encodeTree tree =
 let
 	fun num2binary_aux(0,false) = "0"
     | num2binary_aux(0,true) = ""
 	| num2binary_aux(n,_) = if (n mod 2) = 0 then num2binary_aux((n div 2),true)^"0"
 	    else num2binary_aux((n div 2),true)^"1"
 	fun num2binary 0 = num2binary_aux(0,false)
 		| num2binary n = num2binary_aux(n,true)
     fun char2binary c = num2binary(ord(c))
 	fun max_appearance (Symbol(x,n)) = n
 		| max_appearance (Node((_,_),Symbol(_,n),_)) = n
 		| max_appearance (Node((_,_),_,Symbol(_,n))) = n
 	fun LetterEncodingHist (Symbol(x,n)) = [(x,n)]
     | LetterEncodingHist (Node(_,T1,T2)) = (LetterEncodingHist T1)@(LetterEncodingHist T2)
 	fun complete_zeros(n,lst) = if length(lst) = n then lst else #"0"::complete_zeros(n-1,lst)
     val hist = LetterEncodingHist(tree)
 	val max_app = max_appearance(tree)
 	val max_app_encode = complete_zeros(19,explode(num2binary(max_app)))
 	fun encode_tuple (x,y) = complete_zeros(8,explode(char2binary(x))) @ (complete_zeros(max_app,explode(num2binary(y))))
 	fun append_to_complete lst = if (length(lst) mod 8) = 0 then lst else append_to_complete(lst@[#"0"])
 	fun binary_to_num [] _ = 0
 	    | binary_to_num (x::xs) m = if x = #"1" then (m + (binary_to_num xs (2*m))) else (binary_to_num xs (2*m))
 	fun encode_list [] _= ""
 	    | encode_list (x::xs) temp = if length(temp) = 8 then str(chr(binary_to_num temp 1))^(encode_list xs [x])
 	                               else (encode_list xs (temp@[x]))
 in
 	encode_list (append_to_complete(max_app_encode @ (foldr op@ [] (map encode_tuple hist)))) []
 end;