c4 18-21

Author: seckcoder

src/eval/c4_18.scm

@@ -0,0 +1,60 @@
+; There is a series problem of the scanned out method shown in the exercise.
+(lambda ()
+  (let ((u '*unassigned*)
+        (v '*unassigned*))
+    ; Here, when some-expression is evaluated, if they contain circular dependance
+    ; like solve has, u/v may be evaluated, in which case an error reported.
+    (let ((a 'some-expression)
+          (b 'some-expression))
+      (set! u a)
+      (set! v b))
+    'expressions))
+
+
+; here shows the case
+
+(define (solve f y0 dt)
+  (define y (integral (delay dy) y0 dt))
+  (define dy (stream-map f y))
+  y)
+
+; ->
+
+(define solve
+  (lambda (f y0 dt)
+    (let ((y '*assigned*)
+          (dy '*assigned*))
+      (let ((a (integral (delay dy) y0 dt))
+            (b (stream-map f y)))
+        (set! y a)
+        (set! dy b)
+        y))))
+
+; ->
+(define solve
+  (lambda (f y0 dt)
+    ((lambda (y dy)
+       (let ((a (integral (delay dy) y0 dt))
+             (b (stream-map f y)))
+         (set! y a)
+         (set! dy b)
+         y))
+     '*assigned*
+     '*assigned*)))
+; ->
+(define solve
+  (lambda (f y0 dt)
+    ((lambda (y dy)
+       ((lambda (a b)
+          (set! y a)
+          (set! dy b)
+          y)
+        ; here, procedure args are evaluated, and error reported.
+        (integral (delay dy) y0 dt)
+        (stream-map f y))
+       '*assigned*
+       '*assigned*))
+    ))
+
+
+; apparently, there is no such problem for the one in the text

src/eval/c4_19.scm

@@ -0,0 +1,19 @@
+(load "eval.scm")
+
+; to enable scan-out-defines, try to modify it in eval.scm
+
+(define (demo)
+  (seck-eval '(let ((a 1))
+                (define (f x)
+                  (define b (+ a x))
+                  (define a 5)
+                  (+ a b))
+                (f 10))
+             global-env)
+  )
+(let ((a 1))
+  (define (f x)
+    (define b (+ a x))
+    (define a 5)
+    (+ a b))
+  (f 10))

src/eval/c4_20.scm

@@ -0,0 +1,57 @@
+; a) in eval.scm
+; b) let's do some evaluation manually
+
+; for letrec
+
+(letrec ((even?
+           (lambda (n)
+             (if (= n 0)
+               true
+               (odd? (- n 1)))))
+         (odd?
+           (lambda (n)
+             (if (= n 0)
+               false
+               (even? (- n 1))))))
+  <exp>)
+
+; ->
+
+(let ((even? '*assigned*)
+      (odd? '*assigned*))
+  (set! even? ...)
+  (set! odd? ...)
+  <exp>)
+; ->
+((lambda (even? odd?)
+   (set! even? ...)
+   (set! odd? ...))
+ '*assigned*
+ '*assigned*
+ )
+
+; but for let
+
+(let ((even? ...)
+      (odd? ...))
+  (even? x))
+
+; ->
+
+((lambda (even? odd?)
+   (even? x))
+ ; here, when evaluating the following lambda procedure,
+ ; odd?, even? will be looked up in the lambda procedure environment(lexical scoping),
+ ; therefore, they will not be found.
+ (lambda (n)
+   (if (= n 0)
+     true
+     (odd? (- n 1))))
+ (lambda (n)
+   (if (= n 0)
+     false
+     (even? (- n 1))))
+)
+
+; so, the internal diff between letrec and let is, letrec keeps the environment
+; for argument in the let body.

src/eval/c4_21.scm

@@ -0,0 +1,44 @@
+(load "eval.scm")
+
+(define fact-exp '((lambda (n)
+                     ((lambda (fact)
+                        (fact fact n))
+                      (lambda (ft k)
+                        (if (= k 1)
+                          1
+                          (* k (ft ft (- k 1)))))))
+                   10))
+
+; a)
+; (println (seck-eval fact-exp global-env))
+
+
+(define fib-exp '((lambda (n)
+                    ((lambda (fib)
+                       (fib fib 0 1 0)
+                       )
+                     (lambda (fib a b k)
+                       (if (= k n)
+                         b
+                         (fib fib b (+ a b) (+ 1 k))))
+                     ))
+                  10))
+
+; (println (seck-eval fib-exp global-env))
+
+; b)
+
+(define f-exp '(define (f x)
+                 ((lambda (even? odd?)
+                    (even? even? odd? x))
+                  (lambda (ev? od? n)
+                    (if (= n 0)
+                      true
+                      (od? ev? od? (- n 1))))
+                  (lambda (ev? od? n)
+                    (if (= n 0)
+                      false
+                      (ev? ev? od? (- n 1)))))))
+
+(seck-eval f-exp global-env)
+(println (seck-eval '(f 4) global-env))