X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=code%2Fcalculator%2Fcalc4.ml;fp=code%2Fcalculator%2Fcalc4.ml;h=d2fc94e6c8cc73f5b42edba33d22259e2ccc08f8;hp=0000000000000000000000000000000000000000;hb=12c7bba12e14ab2e1ea72a4b95f1aee0c114a188;hpb=2cef07bcbf221a75e0cf0da553be6566a206d68f

diff --git a/code/calculator/calc4.ml b/code/calculator/calc4.ml
new file mode 100644
index 00000000..d2fc94e6
--- /dev/null
+++ b/code/calculator/calc4.ml
@@ -0,0 +1,118 @@
+(* calc3.ml, enhanced with Mutable Cells *)
+
+	type term =
+		  Intconstant of int
+		| Multiplication of (term * term)
+		| Addition of (term * term)
+		| Variable of char
+		| Let of (char * term * term)
+		| Iszero of term
+		| If of (term * term * term)
+		| Makepair of (term * term)
+		| First of term
+		| Lambda of (char * term)
+		| Apply of (term * term)
+		| Letrec of (char * term * term)
+		| Newref of term
+		| Deref of term
+		| Setref of (term * term)
+        ;;
+
+	type index = int;;
+
+    type bound_value = Nonrecursive of expressed_value | Recursive_Closure of char * char * term * assignment
+	and assignment = (char * bound_value) list
+    and expressed_value = Int of int | Bool of bool | Pair of expressed_value * expressed_value | Closure of char * term * assignment | Mutcell of index;;
+
+	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 *)
+		match List.assoc var g with
+          | Nonrecursive value -> value
+          | Recursive_Closure (self_var, arg_var, body, savedg) as rec_closure ->
+			  (* we update savedg to bind self_var to rec_closure here *)
+              let savedg' = (self_var, rec_closure) :: savedg
+              in Closure (arg_var, body, savedg')
+        ), s
+	| Let (var_to_bind, t2, t3) ->
+		(* evaluate t3 under a new assignment where var_to_bind has been bound to
+           the result of evaluating t2 under the current assignment *)
+		let (value2, s') = eval t2 g s
+		(* we have to wrap value2 in Nonrecursive *)
+		in let g' = (var_to_bind, Nonrecursive value2) :: 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
+        (* 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 Nonrecursive value2 *)
+		in let savedg' = (arg_var, Nonrecursive value2) :: 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
+        (* evaluate t3 under a new assignment where var_to_bind has been recursively bound to that function value *) 
+		in let g' = (var_to_bind, Recursive_Closure (var_to_bind, arg_var, body, savedg)) :: g
+		in eval t3 g' s'
+	| Newref (t1) ->
+		let (starting_val, s') = eval t1 g s
+		(* note that s' may be different from s, if t1 itself contained any mutation operations *)
+		(* now we want to retrieve the next free index in s' *)
+		in let new_index = List.length s'
+		(* now we want to insert starting_val there; the following is an easy but inefficient way to do it *)
+		in let s'' = List.append s' [starting_val]
+		(* now we return a pair of a wrapped new_index, and the new store *)
+		in (Mutcell new_index, s'')
+	| Deref (t1) ->
+		(* we don't handle cases where t1 doesn't evaluate to a Mutcell *)
+		let (Mutcell index1, s') = eval t1 g s
+		(* note that s' may be different from s, if t1 itself contained any mutation operations *)
+		in (List.nth s' index1, s')
+	| Setref (t1, t2) ->
+		(* we don't handle cases where t1 doesn't evaluate to a Mutcell *)
+		let (Mutcell index1, s') = eval t1 g s
+		(* note that s' may be different from s, if t1 itself contained any mutation operations *)
+		in let (new_value, s'') = eval t2 g s'
+		(* now we create a list which is just like s'' except it has new_value in index1 *)
+		in let rec replace_nth lst m =
+			match lst with
+			| [] -> failwith "list too short"
+			| x::xs when m = 0 -> new_value :: xs
+			| x::xs -> x :: replace_nth xs (m - 1)
+		in let s''' = replace_nth s'' index1
+		(* we'll arbitrarily return Int 42 as the expressed_value of a Setref operation *)
+		in (Int 42, s''')
+    ;;