Practice session 3

 תחביר ממשי ( קונקרטי ) ותחביר מופשט ( אבסטרקטי )  שיטות חישוב : Applicative & Normal Evaluation

: Kinds:, : Kinds:, : Kinds:,, : Kinds:, : Kinds: numbers. : Kinds: #t, #f : Kinds: Restricted sequences of letters, digits, punctuation marks : Kinds:,,,, : Components: Variable: Expression: : Components: Parameter:. Amount: >= 0. Ordered. Body:. Amount: >= 1. Ordered. : Components: Quoted-name: : Components: Predicate: Consequence: Alternative: : Components: Var:. Amount: >= 0. Body:. Amount: >= 1. Ordered. And more…

-> | ’(’ ’)’ -> | | -> | -> Numbers -> ’#t’ | ’#f’ -> Restricted sequences of letters, digits, punctuation marks -> | | | | -> + -> ’define’ -> ’lambda’ ’(’ * ’)’ + -> ’quote’ -> ’cond’ * -> ’(’ + ’)’ -> ’(’ ’else’ + ’)’ -> ’if’ -> ’let’ ’(’ * ’)’ +

 שאלה 1: נרצה להוסיף לשפה ביטוי הדומה ל -if, אבל בלי האלטרנטיבה, שייראה כך : (when pred-exp cons-exps)  דוגמאות : ((when (> x 5) (+ x 3) (when (> x 5) (display x) (* x x))  אילו שינויים צריך לעשות בתחביר ?

: Kinds:, : Kinds:, : Kinds:, : Kinds:,,,, : Components: Predicate: Consequence-exps: Amount: >=1. Ordered,

-> | ’(’ ’)’ -> | -> | | | | -> ’if’ -> ‘when’ + |

 שאלה 2: ראינו שהתחביר הממשי תומך בהגדרת משתנה באופן הבא : -> ‘define’  איך ישתנה התחביר אם נרצה להוסיף אפשרות להגדיר משתנה כך : (x := 3) ?  תשובה : התחביר הממשי ישתנה כך : -> ‘define’ | ‘:=‘ רק !

שתי פונקציות להערכת ביטויים ב -Scheme:  applicative-eval(e) eval-substitute-reduce  normal-eval(e) substitute-reduce

 שאלה 4: לכל Binding instance ציינו את תחום ההגדרה (Scope) שלו ואת המופעים הקשורים (Bound instance) אליו. כמו כן, ציינו מופעים חופשיים של משתנים : 1(define even? (lambda (n) 2(eq? (/ n 2) 0))) 3(define expt? (lambda (n) 4 (cond ((= n 1) #t) 5((even? n) (expt? (/ n 2))) 6 (else #f))))

 שאלה 5: התבוננו בקטע הקוד הבא. למה צריך לבצע renaming? >(define z not) >(((lambda (x) (lambda (z) (x z))) (lambda (w) (z w))) #f)

 שאלה 5: >(define z not) >(((lambda (x) (lambda (z1) (x z1))) (lambda (w) (z w))) #f)

 שאלה 6: applicative-eval [ ((lambda (x z) (* (+ x z) z)) 1 (+ 1 2) ) ] applicative-eval [ (lambda (x z) (* (+ x z) z)) ] ==> applicative-eval [1] ==> 1 applicative-eval [(+ 1 2)] applicative-eval [+] ==> # applicative-eval [1] ==> 1 applicative-eval [2] ==> 2 ==>3

(* (+ x z) z) {x = 1} ==> (* (+ 1 z) z) (* (+ 1 z) z) {z = 3} ==> (* (+ 1 3) 3) reduce: applicative-eval [(* (+ 1 3) 3)] applicative-eval [*] ==> # applicative-eval [(+ 1 3)] applicative-eval [+] ==> # applicative-eval [1] ==> 1 applicative-eval [3] ==> 3 ==> 4 applicative-eval [3]==> 3 ==> 12

 שאלה 8: >(define test (lambda (x y) (if (= x 0) 0 y))) >(define zero-div (lambda (n) (/ n 0))) ;division by zero!  מהן תוצאות החישוב : (test 0 (zero-div 5)) בשני האלגוריתמים?

>(define test (lambda (x y) (if (= x 0) 0 y))) >(define zero-div (lambda (n) (/ n 0))) ;division by zero! >(test 0 (zero-div 5)) normal-eval [ (test 0 (zero-div 5)) ] normal-eval [test]==> (if (= x 0) 0 y)) {x = 0}==> (if (= 0 0) 0 y)) (if (= 0 0) 0 y)) {y = (zero-div 5)}==> (if (= 0 0) 0 (zero-div 5) )) reduce: normal-eval[(if (= 0 0) 0 (zero-div 5)))] normal-eval[(= 0 0)] normal-eval[ = ] ==># normal-eval[ 0 ] ==>0 ==> #t normal-eval[0] ==> 0 ==>0 מה היה קורה אם היינו מחשבים לפי applicative-eval??

 שאלה 7: התבוננו בקטע הקוד הבא : >(define loop (lambda (x) (loop x))) >(define g (lambda (x) 5))  מה יקרה לאחר הפעלת השורה הבאה לפי כל אחת משיטות החישוב ? >(g (loop 0))

 שאלה 9: איך אפשר לדעת לפי איזו שיטה עובר האינטרפרטר ? >(define f (lambda(x) 1) >(define g (lambda (x) 2)  אם אין side-effects נקבל רק את הערך שיוחזר מחישוב הביטוי, וערך זה הוא תמיד זהה בהנחה שהחישוב מסתיים בשתי השיטות. אז ניצור side-effects...

 שאלה 9: איך אפשר לדעת לפי איזו שיטה עובד האינטרפרטר ? >(define f (lambda(x) (display ‘f) 1) >(define g (lambda (x) 2) >(g (f 3)) Applicative: ‘f2 Normal:2

 שאלה 10: ניזכר במימוש האיטרטיבי להעלאה בחזקה שראינו בשיעור שעבר : (define exp (lambda (b e) (exp-iter b e 1))) (define exp-iter (lambda (b e acc) (cond ((= e 0) acc) (else (exp-iter b (- e 1) (* b acc))))))  מהו ה -Scope של הפונקציה exp-iter? האם זה באמת נחוץ ?

 ניסוח מחדש : (define exp (lambda (b e) (letrec ((exp-iter (lambda (b e acc) (cond ((= e 0) acc) (else (exp-iter b (- e 1) (* b acc))))))) (exp-iter b e 1))))  מה עוד אפשר לשפר..?