X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?a=blobdiff_plain;f=code%2Fcalculator%2Fcalc6.ml;fp=code%2Fcalculator%2Fcalc6.ml;h=0000000000000000000000000000000000000000;hb=fd698b815e417dec463cb0f0e9ed056ab83daed6;hp=9cf5abc35f5a4f95a07c908a96467ad86cd71acf;hpb=573a8b36ce653c84c2aecb2b81ef99128cb41d13;p=lambda.git

diff --git a/code/calculator/calc6.ml b/code/calculator/calc6.ml
deleted file mode 100644
index 9cf5abc3..00000000
--- a/code/calculator/calc6.ml
+++ /dev/null
@@ -1,108 +0,0 @@
-(* calc6.ml: calc3.ml enhanced with Mutable Variables *)
-
-    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)
-    ;;
-
-    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''
-    ;;
-