שאלה 1: מערכת המרת טיפוסים (Casting)

ניתוח דוגמאות ההרצה ומעקב (Trace)

מימוש טכני - הקוד שלנו

1. קובץ lang.scm - הוספת חוקי ה-Lexer וה-Parser:

(type ("int") int-type)
(type ("bool") bool-type)
(expression ("<" type ">" "(" expression ")") cast-exp)

2. קובץ interp.scm - מימוש cast-exp והמרה נרמזת ב-if-exp:

; בתוך פונקציית value-of:
(cast-exp (typ exp1)
  (let ((val (value-of exp1 env)))
    (cases type typ
      (int-type ()
        (cases expval val
          (num-val (num) val)
          (bool-val (bool) (if bool (num-val 1) (num-val 0)))
          (else (eopl:error 'value-of "Cannot cast to int: ~s" val))))
      (bool-type ()
        (cases expval val
          (bool-val (bool) val)
          (num-val (num) (if (zero? num) (bool-val #f) (bool-val #t)))
          (else (eopl:error 'value-of "Cannot cast to bool: ~s" val)))))))

; שינוי if-exp להמרה נרמזת:
(if-exp (exp1 exp2 exp3)
  (let ((val1 (value-of exp1 env)))
    (let ((is-true (cases expval val1
                     (bool-val (b) b)
                     (num-val (n) (not (zero? n))) ; המרה נרמזת!
                     (else (eopl:error 'if "Condition must be bool or num")))))
      (if is-true (value-of exp2 env) (value-of exp3 env)))))

שאלה 2: לולאת do מתקדמת

מעקב זרימה לדוגמת המטלה (Trace)

do(
  <a 0 4>
  <b 7 -(a,2)>
  <c -(b,1) -(a,b)>
  [zero? (b) -(a,c)]
  [zero? (-(c,-2)) -(a,5)]
)

מימוש טכני - הקוד שלנו

קובץ lang.scm - SLLGen יארוז את הרשימות המקבילות אוטומטית:

(expression
  ("do" "("
    (arbno "<" identifier expression expression ">")
    (arbno "[" expression expression "]")
  ")")
  do-exp)

קובץ interp.scm - פונקציות העזר והלולאה הראשית ב-value-of:

; פונקציית עזר לאתחול סדרתי. שימו לב שהיא מעדכנת את ה-env ככל שמתקדמים.
(define eval-inits
  (lambda (ids inits env)
    (if (null? ids)
        env
        (let ((val (value-of (car inits) env)))
          (eval-inits (cdr ids) (cdr inits) (extend-env (car ids) val env))))))

; מנוע הלולאה:
(do-exp (ids inits steps bools results)
  (let ((init-env (eval-inits ids inits env)))
    (letrec
      ((loop
         (lambda (curr-env)
           (let ((res (check-conditions bools results curr-env)))
             (if res
                 (car res) ; עטפנו את התוצאה ב-list במידה והוחזר #f (כדי להבדיל מכשלון בתנאי)
                 (let ((new-vals (eval-step-values ids steps curr-env)))
                   ; הסתרת הערכים הישנים באמצעות extend-env-multi וריצה מחודשת
                   (loop (extend-env-multi ids new-vals curr-env))))))))
      (loop init-env))))

הבעיה הקלאסית: באיזה משתנה נשתמש?

התבוננו בקוד הבא שכתוב בשפת PROC. שאלה זו (על הטיותיה) מופיעה כמעט בכל מבחן:

let x = 3 
in let f = proc (z) -(z, x)  % הפונקציה משתמשת ב-x (משתנה חופשי!)
   in let x = 4              % כאן x השתנה ל-4.
      in (f 10)              % הפעלת הפונקציה.

השאלה הגדולה: כשהפונקציה רצה בסוף ומחשבת -(z, x) (כלומר 10 פחות x), באיזה x היא תשתמש? ב-3 או ב-4?

הדמיה השוואתית: סקופ לקסיקלי מול דינמי (Lexical vs Dynamic Scoping) הדמיה אינטראקטיבית

ראו כיצד מנוע ההרצה מחפש משתנים בכל אחד מהמודלים עבור הקוד:
let x = 3 in let f = proc(z) -(z, x) in let x = 4 in (f 10)