Principles of Programming Languages - PowerPoint Presentation

Slide1

Principles of Programming Languages

Practice session 3

תחביר ממשי (קונקרטי) ותחביר מופשט (אבסטרקטי)

שיטות חישוב:

Applicative & Normal Evaluation

Partial EvaluationSlide2

תחביר מופשט

<scheme-exp>:

Kinds: <exp>, <define>

<exp>:

Kinds: <atomic>, <composite><atomic>: Kinds: <number>, <boolean>, <variable><composite>: Kinds: <special>, <form><number>: Kinds: numbers.<boolean>: Kinds: #t, #f<variable>: Kinds: Restricted sequences of letters, digits, punctuation marks<special>: Kinds: <lambda>, <quote>, <cond>, <if>

<define>:

Components: Variable: <variable>

Expression: <exp>

<lambda>:

Components: Parameter: <variable>. Amount: >= 0. Ordered.

Body: <exp>. Amount: >= 1 . Ordered.

<quote>:

Components: Quoted-name: <variable>

<if>:

Components: Predicate: <exp>

Consequence: <exp>

Alternative: <exp>

And more…Slide3

<scheme-exp> -> <exp> | ’(’ <define> ’)’

<exp> -> <atomic> | ’(’ <composite> ’)’<atomic> -> <number> | <

boolean

> | <variable>

<composite> -> <special> | <form><number> -> Numbers<boolean> -> ’#t’ | ’#f’<variable> -> Restricted sequences of letters, digits, punctuation marks<special> -> <lambda> | <quote> | <cond> | <if> | <let><form> -> <exp>+<define> -> ’define’ <variable> <exp><lambda> -> ’lambda’ ’(’ <variable>* ’)’ <exp>+<quote> -> ’quote’ <variable><cond> -> ’cond’ <condition-clause>* <else-clause><condition-clause> -> ’(’ <exp> <exp>+ ’)’<else-clause> -> ’(’ ’else’ <exp>+ ’)’<if> -> ’if’ <exp> <exp> <exp>

<let> -> ’let’ ’(’ <

var-initialization>* ’)’ <exp>+

תחביר ממשי Slide4

שאלה 1: נרצה להוסיף לשפה ביטוי הדומה ל-

if, אבל בלי האלטרנטיבה, שייראה כך: (when pred

-exp cons-

exp

s)דוגמאות:((when (> x 5) (+ x 3)(when (> x 5) (display x) (* x x))אילו שינויים צריך לעשות בתחביר?תחביר ממשי ותחביר מופשט Slide5

<scheme-exp>:

Kinds: <exp>, <define><exp>:

Kinds: <atomic>, <composite>

<composite>:

Kinds: <special>, <form><special>: Kinds: <lambda>, <quote>, <cond>, <if> <when>: Components: Test: <exp> Body: <exp>+ Amount: >=1. Ordered

תחביר מופשט

,

<when>Slide6

<scheme-exp> -> <exp> | ’(’ <define> ’)’

<exp> -> <atomic> | ’(’ <composite> ’)’<composite> -> <special> | <form>

<special> -> <lambda> | <quote> | <

cond

> | <if> | <let><if> -> ’if’ <exp> <exp> <exp><when> -> ‘when’ <exp> <exp>+תחביר ממשי | <when>Slide7

שאלה 2: ראינו שהתחביר ה

ממשי תומך בהגדרת משתנה באופן הבא:<define> -> ‘define’ <variable> <exp>

איך ישתנה התחביר אם נרצה להוסיף אפשרות להגדיר משתנה כך:

(x is 3) ?תשובה: התחביר הממשי ישתנה כך:<define> -> ‘define’ <variable> <exp>תחביר ממשי ותחביר מופשט | <variable> ‘is‘ <exp>

רק

!Slide8

שתי פונקציות להערכת ביטויים ב-Scheme

:applicative-eval(e)

eval

-substitute-reducenormal-eval(e) substitute-reduceשיטות חישובSlide9

שאלה 4: לכל

מופע קושר (Binding Instance) ציינו את

תחום ההגדרה

(

Scope) שלו ואת המופעים הקשורים (Bound Occurrence) אליו. כמו כן, ציינו מופעים חופשיים של משתנים: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))))

שיטות חישובSlide10

שאלה 5: התבוננו בקטע הקוד הבא. למה צריך לבצע

renaming?

>(define z not)

>(

((lambda (x) (lambda (z) (x z))) (lambda (w) (z w))) #f)

Renaming & SubstitutionSlide11

>(

define z not)

>(

(

(lambda (x) (lambda (z) (x z))) (lambda (w) (z w))) #f)שיטות חישוב

>(define z not)

>(

(

(

lambda (x)

(lambda (z1) (x z1))

)

(lambda (w1) (z w1))

)

#f)Slide12

שאלה 6:

applicative-eval

[

(

(lambda (x z) (* (+ x z) z)) 1 (+ 1 2) ) ] applicative-eval [ (

lambda (x z) (* (+ x z) z)

) ] ==> <Closure (x z) (* (+ x z) z)>

applicative-

eval [1] ==> 1 applicative-

eval

[(+ 1 2)]

applicative-

eval

[+] ==> #<primitive-procedure +>

applicative-

eval

[1] ==> 1

applicative-

eval

[2] ==> 2

==>3

שיטות חישובSlide13

(* (+ x z) z) {x = 1} ==> (* (+ 1 z) z)

(* (+ 1 z) z) {z = 3} ==> (* (+ 1 3) 3)

reduce:

applicative-

eval [(* (+ 1 3) 3)] applicative-eval [*] ==> #<primitive-procedure *> applicative-eval [(+ 1 3)] applicative-eval [+] ==> #<primitive-procedure +> applicative-

eval

[1] ==> 1 applicative-eval

[3] ==> 3

==> 4 applicative-eval

[3]==> 3

==> 12

שיטות חישובSlide14

שאלה 7: התבוננו בקטע הקוד הבא:

>(define loop (lambda (x) (loop x)))>(define g (lambda (

x y) y))

מה יקרה לאחר הפעלת השורה הבאה לפי כל אחת משיטות החישוב?

>(g (loop 0) 7)שיטות חישובSlide15

שאלה 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)) בשני האלגוריתמים?

שיטות חישובSlide16

>(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]==> <closure (lambda (x y) (if (= x 0) 0 y))> (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

[ = ] ==>#<primitive-procedure =>

normal-

eval

[ 0 ] ==>0

normal-

eval

[ 0 ] ==>0

==> #t

normal-

eval

[0] ==> 0

==>0

מה היה קורה אם היינו מחשבים לפי

applicative-

eval

??Slide17

שאלה 9

: איך אפשר לדעת לפי איזו שיטה עובר האינטרפרטר?

>(define f

(lambda(x) 1)

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

שאלה 9

: איך אפשר לדעת לפי איזו שיטה עובד האינטרפרטר?

> (

define normal

(lambda () (display 'applicative) 0 ))> (define test (lambda(x) 1))> (test (normal))Applicative: ‘applicative 1

Normal:

1

שיטות חישובSlide19

שאלה

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

?

שיטות חישובSlide20

ניסוח מחדש:

(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))))

מה עוד אפשר לשפר..?

שיטות חישוב