1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

חלק א': עדכון מבני הנתונים (data-structures.scm)

; נוסיף Variant חדש לערכי השפה המייצג רשימה
(define-datatype expval expval?
  ...
  (list-val
    (vals (list-of expval?))))

; פונקציות עזר לבדיקת הטיפוס של ערך מחושב בזמן ריצה
(define expval-num?
  (lambda (v)
    (cases expval v
      (num-val (num) #t)
      (else #f))))

(define expval-bool?
  (lambda (v)
    (cases expval v
      (bool-val (bool) #t)
      (else #f))))

(define expval-proc?
  (lambda (v)
    (cases expval v
      (proc-val (proc) #t)
      (else #f))))

חלק ב': עדכון המפרש (interp.scm)

; בתוך cases של value-of:
(foreach-exp (typ var exps body)
  ; 1. הערכת כל ביטויי הרשימה בעזרת map
  (let ((evaluated-vals (map (lambda (e) (value-of e env)) exps)))
    
    ; 2. סינון האיברים לפי הטיפוס שנבחר (typ יכול להיות סמל כמו 'int או variant של datatype)
    (let ((filtered-vals
            (filter (lambda (v)
                      (cond
                        ((eqv? typ 'int) (expval-num? v))
                        ((eqv? typ 'bool) (expval-bool? v))
                        ((eqv? typ 'func) (expval-proc? v))
                        (else (eopl:error 'foreach "Unknown filter type ~s" typ))))
                    evaluated-vals)))
      
      ; 3. הרצת גוף הלולאה על כל אחד מהערכים המסוננים (כל פעם בסביבה מורחבת)
      (let ((results
              (map (lambda (v)
                     (value-of body (extend-env var v env)))
                   filtered-vals)))
        
        ; 4. אריזת התוצאות בתוך list-val והחזרתן
        (list-val results)))))

התוכנית לניתוח

let y = 30
in
zero?( ((proc(x) -(x, 5)) -(y, 25)) )

1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

חלק א': עדכון מבני הנתונים (data-structures.scm)

; נוסיף Variant המייצג ערך של אירוע (מחזיק כתובת זיכרון ב-Store)
(define-datatype expval expval?
  ...
  (event-val
    (ref reference?)))

; חולץ מתאים לקבלת הכתובת מתוך האירוע
(define expval->event-ref
  (lambda (v)
    (cases expval v
      (event-val (ref) ref)
      (else (eopl:error 'expval->event-ref "Expected an event, got ~s" v)))))

חלק ב': עדכון המפרש (interp.scm)

; בתוך cases של value-of:

  ; 1. יצירת אירוע ריק והקצאת תא זיכרון עבורו
  (event-create-exp ()
    (event-val (newref '())))

  ; 2. רישום פרוצדורות לאירוע קיים
  (event-add-exp (evnt-exp procs-exps)
    (let ((ev-val (value-of evnt-exp env)))
      (let ((ref (expval->event-ref ev-val)))
        (let ((current-procs (deref ref))
              (new-procs (map (lambda (e) (value-of e env)) procs-exps)))
          
          ; בדיקת תקינות: ודא שכל האלמנטים המתווספים הם אכן פרוצדורות!
          (for-each (lambda (p)
                      (cases expval p
                        (proc-val (proc) #t)
                        (else (eopl:error 'event-add "event cannot contain non-procedure elements"))))
                    new-procs)
          
          ; עדכון רשימת הפרוצדורות ב-Store
          (setref! ref (append current-procs new-procs))
          
          ; החזרת ערך דאמי
          (num-val 27)))))

  ; 3. שינוי קריאת פונקציה (call-exp) לתמיכה כפולה
  (call-exp (rator rand)
    (let ((rator-val (value-of rator env))
          (rand-val (value-of rand env)))
      (cases expval rator-val
        ; א' - פקודה רגילה: הפעל פרוצדורה רגילה
        (proc-val (proc)
          (apply-procedure proc rand-val))
        
        ; ב' - הרחבה: הפעלת אירוע
        (event-val (ref)
          (let ((procs (deref ref)))
            (if (null? procs)
                ; שגיאה אם האירוע ריק כפי שנדרש בדוגמה 6
                (eopl:error 'event-call "cannot invoke an empty event")
                
                ; פונקציה רקורסיבית מקומית שמריצה את כל הפרוצדורות ומחזירה את ערך האחרונה
                (letrec ((run-all 
                           (lambda (ps last-val)
                             (if (null? ps)
                                 last-val
                                 (let ((p (car ps)))
                                   ; שליפת הפרוצדורה מתוך ה-Variant
                                   (let ((proc-obj (cases expval p 
                                                     (proc-val (pr) pr)
                                                     (else (eopl:error 'event-call "Invalid proc object")))))
                                     (let ((res (apply-procedure proc-obj rand-val)))
                                       (run-all (cdr ps) res))))))))
                  (run-all procs (num-val 27))))))
        
        (else (eopl:error 'call "Only procedure or event can be invoked")))))

; ריצה 1: תוצאה (num-val 100)
(run "let Colors = enum { Red, Green, Blue }
      let c = <Colors.Green>
      in
      match [Colors::c]
        ?Red  => 10;
        ?Green => 100;
        ?Blue => 1000;")

; ריצה 2: c הוא ה-identifier-val עצמו, תוצאה (identifier-val 'Green)
(run "let Colors = enum { Red, Green, Blue }
      let c = <Colors.Green>
      in c")

; ריצה 3: שגיאה - match לא מכסה את כל האיברים
interp.scm: match-exp: match cases is not correspond to enum Colors cases

; ריצה 4: שגיאה - i אינו enum
interp.scm: enum-elmt-exp: not an enum

; ריצה 5: שגיאה - Yellow לא קיים ב-Colors
interp.scm: enum-elmt-exp: Yellow not found

; ריצה 6: שגיאה - enum ריק
interp.scm: enum-exp: empty identifier list in enum definition

; ריצה 7: תוצאה (num-val 170)
(run "let Foods = enum { Banana, Humus, Hamburger }
      let Calories = proc (x)
        match [Foods::x]
          ?Banana    => 90;
          ?Humus     => 170;
          ?Hamburger => 300;
      in
      (Calories <Foods.Humus>)")

✅ פתרון שלב-אחר-שלב

שלב 1: הגדרת ערכים (Values)

נצטרך שני ערכים חדשים:

; ב-interp.scm — הגדרת טיפוסי הערכים:
(define-datatype expval expval?
  ...
  (enum-val     ; ערך enum — מחזיק רשימת מזהים
    (ids (list-of symbol?)))
  (identifier-val ; ערך מזהה — מחזיק סימבול בודד
    (id symbol?))
  ...)

שלב 2: case עבור enum-exp

כשמגיעים לביטוי enum { Red, Green, Blue }, צריך לבנות enum-val:

(enum-exp (ids)
  ; בדיקת שגיאה: רשימה ריקה אסורה
  (if (null? ids)
    (error 'enum-exp "empty identifier list in enum definition")
    (enum-val ids)))

שלב 3: case עבור enum-elmt-exp

כשמגיעים לביטוי <Colors.Green>:

(enum-elmt-exp (enm-exp id)
  (let ((enm-val (value-of enm-exp env)))
    ; בדיקה: האם enm הוא באמת enum?
    (cases expval enm-val
      (enum-val (ids)
        ; בדיקה: האם id קיים ב-enum?
        (if (memv id ids)
            (identifier-val id)
            (error 'enum-elmt-exp "~s not found" id)))
      (else
        (error 'enum-elmt-exp "not an enum")))))

שלב 4: case עבור match-exp

זהו החלק המורכב ביותר. ה-match חייב לבדוק:

1. האם ה-enmid (מזהה ה-enum כ-identifier בסביבה) מצביע ל-enum-val?
2. האם ה-exp1 (הביטוי שאחרי ::) מוערך ל-identifier-val?
3. האם רשימת ה-enmids (ה-cases) תואמת בדיוק לרשימת ה-ids של ה-enum?
4. מצא את ה-case שה-id שלו שווה ל-identifier-val שהתקבל, והחזר את הביטוי המתאים.

(match-exp (enmid exp1 enmids exps)
  ; שלב א: הוצא את ה-enum מהסביבה
  (let* ((enum-val-from-env (apply-env env enmid))
         ; שלב ב: הוצא את הרשימת-מזהים של ה-enum
         (enum-ids
           (cases expval enum-val-from-env
             (enum-val (ids) ids)
             (else (error 'match-exp "enmid is not an enum"))))
         ; שלב ג: הערך את הביטוי שמגיע אחרי ::
         (actual-val (value-of exp1 env))
         ; שלב ד: חלוץ את ה-identifier מתוך identifier-val
         (actual-id
           (cases expval actual-val
             (identifier-val (id) id)
             (else (error 'match-exp "expression is not an enum element")))))
    ; שלב ה: ודא שה-cases תואמים לאיברי ה-enum בדיוק
    (if (not (equal? (sort enmids symbol<?) (sort enum-ids symbol<?)))
        (error 'match-exp "match cases is not correspond to enum ~s cases" enmid)
        ; שלב ו: מצא את הביטוי התואם להרץ אותו
        (let loop ((ids enmids) (es exps))
          (cond
            ((null? ids)
             (error 'match-exp "no matching case found for ~s" actual-id))
            ((eqv? (car ids) actual-id)
             (value-of (car es) env))
            (else
             (loop (cdr ids) (cdr es))))))))

📊 מעקב אחר ריצה 1: (num-val 100)

(run "let w1=100
      let w2=300
      let w3=500
      in
      begin
        for/proc (p: [a,b,c,d] : [-(a,1), -(b,2), -(c,3), -(d,4)])
          <skip:  zero?((p 2))>
          <break: zero?((p 12))>
          <skip:  zero?((p 200))>
          if zero?((p 1))
          then set w1 = 7000
          else if zero?((p 3))
               then set w2 = p
               else set w3 = (p w1)
        (w2 w3)
      end")
; תוצאה: (num-val 6993)

📊 מעקב צעד-אחר-צעד

✅ מימוש: case ב-value-of

(forproc-exp (Id Ids Bodies Guards Body)
  ; שלב א: בנה רשימת פרוצדורות מ-Ids ו-Bodies
  (let ((procs (map (lambda (id body)
                      (proc-val (procedure id body env)))
                    Ids Bodies)))
    ; שלב ב: לולאה על הפרוצדורות
    (let loop ((ps procs))
      (if (null? ps)
          ; שלב ג: הלולאה הסתיימה — הרץ את Body הסופי
          (value-of Body env)
          ; שלב ד: קשור p לפרוצדורה הנוכחית
          (let* ((current-proc (car ps))
                 (new-env (extend-env Id (newref current-proc) env))
                 ; שלב ה: בדוק Guards
                 (guard-result (eval-guards Guards new-env)))
            (cond
              ((eq? guard-result 'skip)
               (loop (cdr ps)))       ; דלג לאיטרציה הבאה
              ((eq? guard-result 'break)
               (value-of Body env))   ; עצור ורוץ Body
              (else
               ; שלב ו: הרץ את גוף הלולאה
               (value-of Id new-env)  ; מעריך את ה-p (side effect)
               (loop (cdr ps)))))))))

; פונקציית עזר לבדיקת Guards:
(define (eval-guards guards env)
  (if (null? guards)
      'none
      (let ((g (car guards)))
        (cases guard g
          (skip-guard (exp)
            (if (expval->bool (value-of exp env))
                'skip
                (eval-guards (cdr guards) env)))
          (break-guard (exp)
            (if (expval->bool (value-of exp env))
                'break
                (eval-guards (cdr guards) env)))))))

let p = proc (a) -(a, -(0, a))
in
let a = 9
in
if/let a = 6
then a×              ; (×=הביטוי בתנאי ה-then)
else (p a)
in zero? (-( (p a), a) )
                    

✅ מעקב שלב-אחר-שלב

1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

חלק א': עדכון מבני הנתונים (data-structures.scm)

; נוסיף קופסה חדשה לערכי השפה המייצגת Tuple
(define-datatype expval expval?
  ... ; num-val, bool-val, proc-val
  (tuple-val
    (vals (list-of expval?)))) ; שומר רשימה של ערכים מחושבים

; חובה להוסיף חולץ (Extractor)
(define expval->tuple
  (lambda (v)
    (cases expval v
      (tuple-val (vals) vals)
      (else (eopl:error 'expval->tuple "Expected a tuple, got ~s" v)))))

חלק ב': עדכון המפרש ופונקציית עזר (interp.scm)

; בתוך פונקציית value-of:
(cases expression exp
  ...
  ; 1. יצירת Tuple
  (tuple-exp (exps)
    ; מעריכים כל AST node בעזרת map
    (let ((evaluated-vals (map (lambda (e) (value-of e env)) exps)))
      (tuple-val evaluated-vals)))

  ; 2. פירוק ה-Tuple (Multiple Let)
  (tuple-let-exp (vars exp1 body)
    (let ((tuple-value (value-of exp1 env))) ; הערכת צד ימין
      (let ((vals-list (expval->tuple tuple-value))) ; חילוץ הרשימה
        (if (not (= (length vars) (length vals-list)))
            (eopl:error 'tuple-let "Mismatch between vars and values")
            ; פונקציית עזר שבונה את הסביבה המורחבת
            (value-of body (extend-env-list vars vals-list env))))))
)

; פונקציית עזר להרחבת סביבה עם מספר משתנים במקביל (קריטי למבחן!)
(define extend-env-list
  (lambda (vars vals env)
    (if (null? vars)
        env ; תנאי עצירה - נחזיר את הסביבה הסופית שנבנתה
        (extend-env-list 
           (cdr vars) 
           (cdr vals) 
           (extend-env (car vars) (car vals) env)))))

1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

; בתוך value-of:
(cases expression exp
  ...
  (switch-exp (target-exp types ids cond-exps body-exps default-body)
    ; מחשבים את ערך המטרה שיועבר לכל התנאים
    (let ((target-val (value-of target-exp env)))
      
      ; מנוע חיפוש התנאים
      (letrec ((evaluate-cases 
                 (lambda (current-ids current-conds current-bodies)
                   (if (null? current-ids)
                       ; אם לא מצאנו שום התאמה, נריץ דיפולט
                       (value-of default-body env)
                       
                       ; יצירת סביבה מקומית עבור בדיקת המקרה. 
                       ; **חובה newref כי זו שפת Implicit Refs!**
                       (let ((case-env (extend-env (car current-ids) 
                                                   (newref target-val) 
                                                   env)))
                         ; הערכת התנאי (when) בסביבה הזו
                         (let ((cond-result (value-of (car current-conds) case-env)))
                           (if (expval->bool cond-result)
                               ; אמת: מחזירים את תוצאת הגוף של המקרה (וזה יעצור את הרקורסיה)
                               (value-of (car current-bodies) case-env)
                               ; שקר: ממשיכים הלאה לבדוק את התנאים הבאים
                               (evaluate-cases (cdr current-ids) 
                                               (cdr current-conds) 
                                               (cdr current-bodies)))))))))
        ; הפעלת המנוע על הרשימות מהדקדוק
        (evaluate-cases ids cond-exps body-exps))))

1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

; בתוך value-of:
(cases expression exp
  ...
  (foreach-exp (type var exps body)
    ; פונקציית לולאה מקומית רקורסיבית שעוברת על הביטויים
    (letrec ((loop 
               (lambda (remaining-exps)
                 (if (null? remaining-exps)
                     ; תנאי עצירה: חובה להחזיר ערך דאמי בסוף הלולאה!
                     (num-val 27)
                     
                     ; יש עוד איברים:
                     (let ((current-val (value-of (car remaining-exps) env)))
                       (begin
                         ; מריצים את הגוף בתוך סביבה המכילה את המשתנה הנוכחי
                         (value-of body (extend-env var current-val env))
                         
                         ; ממשיכים רקורסיבית לשאר הביטויים
                         (loop (cdr remaining-exps))))))))
      
      ; הפעלה ראשונית של הלולאה
      (loop exps))))

1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

; =========================================
; מבני נתונים (data-structures.scm)
; =========================================
(define-datatype expval expval?
  ...
  (array-val
    (refs (list-of reference?)))) ; רשימת כתובות זיכרון

(define expval->array
  (lambda (v)
    (cases expval v
      (array-val (refs) refs)
      (else (eopl:error 'expval->array "Not an array!")))))

; =========================================
; המפרש (interp.scm)
; =========================================
(cases expression exp
  ...
  ; 1. הקצאת מערך חדש
  (newarray-exp (length-exp value-exp)
    (let ((len (expval->num (value-of length-exp env)))
          (init-val (value-of value-exp env)))
      ; קריאה לפונקציית העזר שמקצה פיזית את התאים
      (array-val (allocate-array len init-val))))

  ; 2. קריאת תא
  (arrayref-exp (array-exp index-exp)
    (let ((arr-refs (expval->array (value-of array-exp env)))
          (idx (expval->num (value-of index-exp env))))
      ; שליפת הכתובת הספציפית בעזרת list-ref (פונקציה מובנית בסקים)
      (let ((target-ref (list-ref arr-refs idx)))
        (deref target-ref)))) ; קריאת הערך האמיתי מהזיכרון

  ; 3. עדכון תא
  (arrayset-exp (array-exp index-exp new-value-exp)
    (let ((arr-refs (expval->array (value-of array-exp env)))
          (idx (expval->num (value-of index-exp env)))
          (new-val (value-of new-value-exp env)))
      (let ((target-ref (list-ref arr-refs idx)))
        (begin
          (setref! target-ref new-val) ; דריסת הערך בזיכרון
          (num-val 27))))) ; חוק ערך הדאמי להשמות!
)

; פונקציית עזר: הקצאת המערך ב-Store
(define allocate-array
  (lambda (size init-val)
    (if (= size 0)
        '() ; סוף הרשימה
        ; יוצרים תא זיכרון אחד, ומשרשרים אותו להמשך ההקצאות
        (cons (newref init-val) 
              (allocate-array (- size 1) init-val)))))

1. הדקדוק שניתן בשאלה

2. הפתרון המלא - Racket

חלק א': עדכון הסביבה (data-structures.scm)

(define-datatype environment environment?
  ...
  ; הבנאי הרקורסיבי המורחב לתמיכה ברשימות פונקציות
  (extend-env-rec*
    (p-names (list-of symbol?))     ; שמות הפונקציות
    (b-vars (list-of symbol?))      ; פרמטרים
    (p-bodies (list-of expression?)); גופים
    (saved-env environment?)))

חלק ב': אלגוריתם החיפוש וההקצאה (environments.scm)

; בתוך cases של apply-env:
(extend-env-rec* (p-names b-vars p-bodies saved-env)
  ; מציאת אינדקס השם בעזרת פונקציית עזר location
  (let ((n (location search-var p-names)))
    (if n
        ; נמצא (n הוא אינדקס מספרי)!
        ; נייצר Closure ונארוז בכתובת זיכרון כי מדובר ב-Implicit Refs
        (newref
          (proc-val
            (procedure 
              (list-ref b-vars n)   ; שולף פרמטר
              (list-ref p-bodies n) ; שולף גוף פונקציה
              env)))                ; env כולל את כל הפונקציות הרקורסיביות!
              
        ; לא נמצא ברשימה, חפש בסביבה השמורה
        (apply-env saved-env search-var))))

; פונקציית עזר למציאת אינדקס ברשימה (חובה להכיר)
(define location
  (lambda (sym syms)
    (cond
      ((null? syms) #f)
      ((eqv? sym (car syms)) 0)
      (else 
        (let ((res (location sym (cdr syms))))
          (if res (+ res 1) #f))))))

1. הדקדוק

2. הפתרון המלא - Racket

; בתוך value-of:
(cases expression exp
  ...
  (while-exp (cond-exp body-exp)
    (letrec ((loop 
               (lambda ()
                 ; הערכת התנאי *בתוך* גוף הלולאה של סקים!
                 (if (expval->bool (value-of cond-exp env))
                     ; אם התנאי אמת: מריצים את הגוף ואז קוראים שוב ללולאה
                     (begin
                       (value-of body-exp env)
                       (loop))
                     ; אם התנאי שקר: יוצאים ומחזירים ערך דאמי
                     (num-val 27)))))
      ; הפעלה ראשונה של הלולאה
      (loop))))

1. הדקדוק

2. הפתרון המלא - Racket

; בתוך value-of:
(cases expression exp
  ...
  (let*-exp (vars exps body)
    ; פונקציה שעושה אקומולציה לסביבה
    (letrec ((evaluate-seq 
               (lambda (remaining-vars remaining-exps current-env)
                 (if (null? remaining-vars)
                     ; כשהרשימות ריקות, מריצים את הגוף על הסביבה הסופית שצברנו
                     (value-of body current-env)
                     
                     ; מעריכים את המשתנה הראשון בסביבה הנוכחית
                     (let ((val (value-of (car remaining-exps) current-env)))
                       ; קריאה רקורסיבית עם סביבה מורחבת עבור המשתנה הבא!
                       (evaluate-seq (cdr remaining-vars)
                                     (cdr remaining-exps)
                                     (extend-env (car remaining-vars) val current-env)))))))
      ; הפעלה מתוך הסביבה ההתחלתית
      (evaluate-seq vars exps env))))

1. הדקדוק

2. הפתרון המלא - Racket

; בתוך value-of:
(cases expression exp
  ...
  (swap-exp (var1 var2)
    ; שליפת כתובות הזיכרון המקוריות (References) מהסביבה
    (let ((ref1 (apply-env env var1))
          (ref2 (apply-env env var2)))
      
      ; קריאת הערכים הפיזיים מה-Store
      (let ((val1 (deref ref1))
            (val2 (deref ref2)))
        
        (begin
          ; החלפת התוכן בזיכרון הפיזי בהצלבה
          (setref! ref1 val2)
          (setref! ref2 val1)
          
          ; ערך dummy כי זוהי פקודת תופעת לוואי
          (num-val 27)))))