c4 16

Author: seckcoder

src/eval/c4_16.scm

@@ -5,3 +5,6 @@
 ; in procedure-body, scan-out-defines is evaluated when
 ; procedure evaluated. It's just a matter of whether
 ; we want the internal definition to be lazy.
+; Note when implement scan-out-defines, to pass
+; a (quote symbol) to the evaluator, you have to
+; pass (quote (quote symbol)), see my explanation in eval.scm

src/eval/demo.scm

@@ -1,23 +1,4 @@
-(define (fib n)
-  (display (let fib-iter ((a 1)
-                 (b 0)
-                 (count n))
-    (if (= count 0)
-      b
-      (fib-iter (+ a b) a (- count 1))))
-           )
-  (display fib-iter)
-  )
-
-
-((lambda ()
-   (define fib-iter
-     (lambda (a b count)
-       (if (= count 0)
-         b
-         (fib-iter (+ a b) a (- count 1))
-         )
-       ))
-   (fib-iter 1 0 10)
-   )
- )
+(let ((b *unassigned*) (a *unassigned*))
+   (set! b (+ a x))
+   (set! a 5)
+   (+ a b c))

src/eval/eval.scm

@@ -237,7 +237,10 @@
   (tagged-list? proc 'procedure))
 
 (define (make-procedure params body-seq env)
-  (list 'procedure params body-seq env))
+  (list 'procedure
+        params
+        (scan-out-defines body-seq)
+        env))
 
 (define (procedure-parameters proc)
   (cadr proc))
@@ -262,16 +265,23 @@
   (let ((definitions (filter definition? proc-body))
         (non-definitions (filter (compose not definition?)
                                  proc-body)))
-    (make-let (map (lambda (exp)
-                     (list (definition-var exp)
-                           '*unassigned*))
-                   definitions)
-              (append (map (lambda (exp)
-                             (list 'set!
-                                   (definition-var exp)
-                                   (definition-value exp)))
+    (if (not (null? definitions))
+      (list (make-let (map (lambda (exp)
+                             (list (definition-var exp)
+                                   ;; Here, we use '', since
+                                   ;; we want to pass a (quote symbol) to the evaluator,
+                                   ;; but not a symbol to the evaluator. The outer quote
+                                   ;; will be used to protect (quote symbol) in
+                                   ;; the naive scheme evaluator.
+                                   ''*unassigned*))
                            definitions)
-                      non-definitions))))
+                      (append (map (lambda (exp)
+                                     (list 'set!
+                                           (definition-var exp)
+                                           (definition-value exp)))
+                                   definitions)
+                              non-definitions)))
+      proc-body)))
 
 ; @(assignment)
 
@@ -610,20 +620,3 @@
                              global-env))
 (define (test-scan-out-definitons)
   (scan-out-defines (procedure-body proc)))
-
-(define (test-scoping)
-  ; if it's lexical scoping, it will return 7
-  ; but if it's dynamic scoping, it will return 8
-  (let ((new-env (make-env global-env)))
-    (seck-eval '(define a 4)
-               new-env)
-    (seck-eval '(define (foo)
-                  (+ a 3))
-               new-env)
-    (seck-eval '(define (bar)
-                  (define a 5)
-                  (foo))
-               new-env)
-    (println (seck-eval '(bar)
-                        new-env))
-    ))

src/eval/scoping.scm

@@ -0,0 +1,18 @@
+(load "eval.scm")
+
+(define (test-scoping)
+  ; if it's lexical scoping, it will return 7
+  ; but if it's dynamic scoping, it will return 8
+  (let ((new-env (make-env global-env)))
+    (seck-eval '(define a 4)
+               new-env)
+    (seck-eval '(define (foo)
+                  (+ a 3))
+               new-env)
+    (seck-eval '(define (bar)
+                  (define a 5)
+                  (foo))
+               new-env)
+    (println (seck-eval '(bar)
+                        new-env))
+    ))