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

diff --git a/code/calculator/calc7.ml b/code/calculator/calc7.ml
new file mode 100644
index 00000000..df675124
--- /dev/null
+++ b/code/calculator/calc7.ml
@@ -0,0 +1,124 @@
+(* calc6.ml, enhanced with Aliases and Passing by Reference *)
+
+	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)
+		| Change of (char * term * term)
+		| Alias of (char * char * term)
+		| Applyalias of (term * char)
+        ;;
+
+	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 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 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 *)
+        (* 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]
+        (* 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
+        (* 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 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 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 *)
+        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)
+        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 *)
+        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 *)
+        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'
+    ;;
+