X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=code%2Fcalculator%2Fcalc7.ml;h=6fc6338d9ccc6edfcd699739d355318261ecac7b;hp=5bfba3853f05be05a3058b163241dba6d9d56f51;hb=060198e29e2a13552ee64c1e489eea555c8b1cae;hpb=bd90f2eb8b87c2f44169fe209c5e35dd113c3d21

diff --git a/code/calculator/calc7.ml b/code/calculator/calc7.ml
index 5bfba385..6fc6338d 100644
--- a/code/calculator/calc7.ml
+++ b/code/calculator/calc7.ml
@@ -1,6 +1,6 @@
 (* calc6.ml, enhanced with Aliases and Passing by Reference *)
 
-	type term =
+    type term =
       Intconstant of int
     | Multiplication of (term * term)
     | Addition of (term * term)
@@ -18,107 +18,107 @@
     | Applyalias of (term * char)
     ;;
 
-	type index = int;;
+    type index = int;;
 
     type bound_value = index;;
     type assignment = (char * bound_value) list;;
-	type expressed_value = Int of int | Bool of bool | Pair of expressed_value * expressed_value | Closure of char * term * assignment;;
+    type expressed_value = Int of int | Bool of bool | Pair of expressed_value * expressed_value | Closure of char * term * assignment;;
 
-	type store = expressed_value list;;
+    type store = expressed_value list;;
 
-	let rec eval (t : term) (g : assignment) (s : store) = match t with
-	  Intconstant x -> (Int x, s)
-	| Multiplication (t1, t2) ->
-		(* we don't handle cases where the subterms don't evaluate to Ints *)
-		let (Int i1, s') = eval t1 g s
-		in let (Int i2, s'') = eval t2 g s'
-		(* Multiplication (t1, t2) should evaluate to an Int *)
-		in (Int (i1 * i2), s'')
-	| Addition (t1, t2) ->
-		let (Int i1, s') = eval t1 g s
-		in let (Int i2, s'') = eval t2 g s'
-		in (Int (i1 + i2), s'')
-	| Variable (var) ->
-		(* we don't handle cases where g doesn't bind var to any value *)
+    let rec eval (t : term) (g : assignment) (s : store) = match t with
+      Intconstant x -> (Int x, s)
+    | Multiplication (t1, t2) ->
+        (* we don't handle cases where the subterms don't evaluate to Ints *)
+        let (Int i1, s') = eval t1 g s
+        in let (Int i2, s'') = eval t2 g s'
+        (* Multiplication (t1, t2) should evaluate to an Int *)
+        in (Int (i1 * i2), s'')
+    | Addition (t1, t2) ->
+        let (Int i1, s') = eval t1 g s
+        in let (Int i2, s'') = eval t2 g s'
+        in (Int (i1 + i2), s'')
+    | Variable (var) ->
+        (* we don't handle cases where g doesn't bind var to any value *)
         let index = List.assoc var g
         (* get value stored at location index in s *)
         in let value = List.nth s index
         in (value, s)
-	| Let (var_to_bind, t2, t3) ->
-		let (value2, s') = eval t2 g s
-		(* note that s' may be different from s, if t2 itself contained any mutation operations *)
+    | Let (var_to_bind, t2, t3) ->
+        let (value2, s') = eval t2 g s
+        (* note that s' may be different from s, if t2 itself contained any mutation operations *)
         (* get next free index in s' *)
-		in let new_index = List.length s'
-		(* now we want to insert value2 there; the following is an easy but inefficient way to do it *)
-		in let s'' = List.append s' [value2]
+        in let new_index = List.length s'
+        (* now we want to insert value2 there; the following is an easy but inefficient way to do it *)
+        in let s'' = List.append s' [value2]
         (* bind var_to_bind to location new_index in the store *)
         in let g' = ((var_to_bind, new_index) :: g)
         in eval t3 g' s''
-	| Iszero (t1) ->
-		(* we don't handle cases where t1 doesn't evaluate to an Int *)
-		let (Int i1, s') = eval t1 g s
-		(* Iszero t1 should evaluate to a Bool *)
-		in (Bool (i1 = 0), s')
-	| If (t1, t2, t3) ->
-		(* we don't handle cases where t1 doesn't evaluate to a boolean *)
-		let (Bool b1, s') = eval t1 g s
+    | Iszero (t1) ->
+        (* we don't handle cases where t1 doesn't evaluate to an Int *)
+        let (Int i1, s') = eval t1 g s
+        (* Iszero t1 should evaluate to a Bool *)
+        in (Bool (i1 = 0), s')
+    | If (t1, t2, t3) ->
+        (* we don't handle cases where t1 doesn't evaluate to a boolean *)
+        let (Bool b1, s') = eval t1 g s
         (* note we thread s' through only one of the then/else clauses *)
-		in if b1 then eval t2 g s'
-		else eval t3 g s'
-	| Makepair (t1, t2) ->
-		let (value1, s') = eval t1 g s
-		in let (value2, s'') = eval t2 g s'
-		in (Pair (value1, value2), s'')
-	| First (t1) ->
-		(* we don't handle cases where t1 doesn't evaluate to a Pair *)
-		let (Pair (value1, value2), s') = eval t1 g s
-		in (value1, s')
-	| Lambda (arg_var, t2) -> (Closure (arg_var, t2, g), s)
-	| Apply (t1, t2) ->
-		(* we don't handle cases where t1 doesn't evaluate to a function value *)
-		let (Closure (arg_var, body, savedg), s') = eval t1 g s
-		in let (value2, s'') = eval t2 g s'
-		(* evaluate body under savedg, except with arg_var bound to a new location containing value2 *)
+        in if b1 then eval t2 g s'
+        else eval t3 g s'
+    | Makepair (t1, t2) ->
+        let (value1, s') = eval t1 g s
+        in let (value2, s'') = eval t2 g s'
+        in (Pair (value1, value2), s'')
+    | First (t1) ->
+        (* we don't handle cases where t1 doesn't evaluate to a Pair *)
+        let (Pair (value1, value2), s') = eval t1 g s
+        in (value1, s')
+    | Lambda (arg_var, t2) -> (Closure (arg_var, t2, g), s)
+    | Apply (t1, t2) ->
+        (* we don't handle cases where t1 doesn't evaluate to a function value *)
+        let (Closure (arg_var, body, savedg), s') = eval t1 g s
+        in let (value2, s'') = eval t2 g s'
+        (* evaluate body under savedg, except with arg_var bound to a new location containing value2 *)
         in let new_index = List.length s''
         in let s''' = List.append s'' [value2]
-		in let savedg' = (arg_var, new_index) :: savedg
-		in eval body savedg' s'''
-	| Letrec (var_to_bind, t2, t3) ->
-		(* we don't handle cases where t2 doesn't evaluate to a function value *)
-		let (Closure (arg_var, body, savedg), s') = eval t2 g s
+        in let savedg' = (arg_var, new_index) :: savedg
+        in eval body savedg' s'''
+    | Letrec (var_to_bind, t2, t3) ->
+        (* we don't handle cases where t2 doesn't evaluate to a function value *)
+        let (Closure (arg_var, body, savedg), s') = eval t2 g s
         in let new_index = List.length s'
         in let savedg' = (var_to_bind, new_index) :: savedg
         in let new_closure = Closure (arg_var, body, savedg')
         in let s'' = List.append s' [new_closure]
         in let g' = (var_to_bind, new_index) :: g
         in eval t3 g' s''
-	| Change (var, t2, t3) ->
-		(* we don't handle cases where g doesn't bind var to any value *)
+    | Change (var, t2, t3) ->
+        (* we don't handle cases where g doesn't bind var to any value *)
         let index = List.assoc var g
         in let (value2, s') = eval t2 g s
-		(* note that s' may be different from s, if t2 itself contained any mutation operations *)
-		(* now we create a list which is just like s' except it has value2 at index *)
-		in let rec replace_nth lst m =
-			match lst with
-			| [] -> failwith "list too short"
-			| x::xs when m = 0 -> value2 :: xs
-			| x::xs -> x :: replace_nth xs (m - 1)
+        (* note that s' may be different from s, if t2 itself contained any mutation operations *)
+        (* now we create a list which is just like s' except it has value2 at index *)
+        in let rec replace_nth lst m =
+            match lst with
+            | [] -> failwith "list too short"
+            | x::xs when m = 0 -> value2 :: xs
+            | x::xs -> x :: replace_nth xs (m - 1)
         in let s'' = replace_nth s' index
         (* evaluate t3 using original assignment function and new store *)
         in eval t3 g s''
-	| Alias (var_to_bind, orig_var, t3) ->
-		(* we don't handle cases where g doesn't bind orig_var to any value *)
+    | Alias (var_to_bind, orig_var, t3) ->
+        (* we don't handle cases where g doesn't bind orig_var to any value *)
         let index = List.assoc orig_var g
         (* bind var_to_bind to the same index in the store *)
         in let g' = ((var_to_bind, index) :: g)
         in eval t3 g' s
-	| Applyalias (t1, var) ->
-		(* we don't handle cases where t1 doesn't evaluate to a function value *)
-		let (Closure (arg_var, body, savedg), s') = eval t1 g s
-		(* we don't handle cases where g doesn't bind var to any value *)
+    | Applyalias (t1, var) ->
+        (* we don't handle cases where t1 doesn't evaluate to a function value *)
+        let (Closure (arg_var, body, savedg), s') = eval t1 g s
+        (* we don't handle cases where g doesn't bind var to any value *)
         in let index = List.assoc var g
-		(* evaluate body under savedg, except with arg_var bound to existing index *)
-		in let savedg' = (arg_var, index) :: savedg
-		in eval body savedg' s'
+        (* evaluate body under savedg, except with arg_var bound to existing index *)
+        in let savedg' = (arg_var, index) :: savedg
+        in eval body savedg' s'
     ;;