PPL

1. PPL Lecture Notes: Chapter 2 Syntax & Formal Semantics

3. Midterm 2007 (let ((x 4) (y 5)) ( + x y (let ((x y) (y x) (+ -)) (+ x y)))) מה הערך של הביטוי?

4. Today • Concrete and Abstract Syntax • Operational Semantics: applicative order and normal order

5. Concrete Syntax • Defines the actual syntax • In Scheme: • Small and simple • Context free grammar • We use BNF notation (next slide)

6. Concrete Syntax • Non-terminals are denoted as <...> • Terminals (tokens) are surrounded with ’ • Optional items are denoted as [<item-x>] • Items repeating 0 or more times end with * • Items repeating 1 or more times end with + • Alternative choices are separated by the | symbol • Grouped items are in parentheses

7. Concrete Syntax <scheme-exp> -> <exp> | ’(’ <define> ’)’ <exp> -> <atomic> | ’(’ <composite> ’)’ <atomic> -> <number> | <boolean> | <variable> <composite> -> <special> | <form> <number> -> Numbers <boolean> -> ’#t’ | ’#f’

8. <scheme-exp> -> <exp> | ’(’ <define> ’)’ <exp> -> <atomic> | ’(’ <composite> ’)’ <atomic> -> <number> | <boolean> | <variable> <composite> -> <special> | <form> <number> -> Numbers <boolean> -> ’#t’ | ’#f’ <variable> -> sequences of letters, digits, punctuation marks <special> -> <lambda> | <quote> | <cond> | <if> | <let> <form> -> <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>+ <var-initialization> -> ’(’ <variable> <exp> ’)’ <scheme-exp> -> <exp> -> ( <composite> ) -> ( <special> ) -> ( <if> ) -> ( if <exp> <exp> <exp> )-> ( if <atomic> <exp> <exp> )-> ( if <boolean> <exp> <exp> ) -> ( if #f <exp> <exp> ) -> ( if #f <exp> <atomic> ) -> ( if #f <exp> number) -> ( if #f <exp> 2) -> ( if #f ( <composite> ) 2) -> ( if #f ( <form> ) 2) -> ( if #f ( <exp> <exp> <exp> ) 2) -> ( if #f ( <atomic> <exp> <exp> ) 2) -> ( if #f ( <variable> <exp> <exp> ) 2) -> ( if #f ( / <exp> <exp> ) 2) -> ( if #f ( / <atomic> <exp> ) 2) -> ( if #f ( / <number> <exp> ) 2) -> ( if #f ( / 1 <exp> ) 2) -> ( if #f ( / 1 <atomic> ) 2) -> ( if #f ( / 1 <number> ) 2) -> ( if #f ( / 1 0 ) 2)

9. Abstract Syntax • Emphasizes the components • Ignores syntactic parts irrelevant to semantics (like order of components, for example) • ASP • A parser for abstract syntax • an interface to the syntax • Uses a tree for that

10. Abstract Syntax <scheme-exp>: Kinds: <exp>, <define> <exp>: Kinds: <atomic>, <composite> <atomic>: Kinds: <number>, <boolean>, <variable> … <define>: Components: Variable: <variable> Expression: <exp>

11. Possible ASP Tree for the expression: (lambda (x y) (+ x y))

12. Operational Semantics • Actually an eval(exp) algorithm for Scheme expressions • Defined as a set of evaluation rules

13. Formalism: Definitions Binding instance (or declaration): a variable occurrence to which other occurrences refer. In Scheme: Variables occurring as lambda parameters are binding instances (also let!) Top level (non-nested) defined variables (in a define form) are binding instances(declarations). No internal “defines” are allowed!

14. Scope Scope of a binding instance is the region of the program text in which variable occurrences refer to the value that is bound by the variable declaration (where the variable declaration is recognized) In Scheme: Scope of lambda parameters is the entire lambda expression (or let body) Scope of define variables is the entire program, from the define expression and on: Universal / global scope

15. Bound Occurrence Occurrence of variable x that is not a binding instance and is contained within the scope of a binding instance x. The binding instance (declaration) that binds an occurrence of x is the most nested declaration of x that includes the x occurrence in its scope.

16. Free Occurrence Free occurrence: An occurrence of variable x that is not a binding instance, and is not bound.

17. Renaming • Bound variables can be renamed without changing the semantics (kind like renaming in Java Eclipse) (lambda (x) x) <=> (lambda (y) y)

18. Substitution New definition! A substitution s is a mapping from a finite set of variables to a finite set of values. A pair <x,s(x)> is called binding, and written x=x(x) Substitutions are written using set notions: {x=3, y=a, w=<closure>}

19. Application of Substitution Given substitution s and expression E: E◦s: • Renaming of E and values in s. • Replacing all free occurrence of variables of s in E by their corresponding values.

20. Application of Substitution No renaming; no replacement 10◦{x = 5} = 10 No renaming; just replacement (+ x y)◦{x = 5} = (+ 5 y) Renaming and replacement ((+ x ((lambda (x) (+ x 3)) 4)))◦{x = 5} = ((+ 5 ((lambda (x1) (+ x1 3)) 4)))

21. Applicative order evaluation rules Combination... (<operator> <operand1> …… <operand n>) • Evaluate <operator> to get the procedure • evaluate <operands> to get the arguments • If <operator> is primitive: do whatever magic it does • If <operator> is compound: evaluate body with formal parameters replaced by arguments Eager!

22. Normal order evaluation Combination … (<operator> <operand1> …… <operand n>) • Evaluate <operator> to get the procedure • evaluate <operands> to get the arguments • If <operator> is primitive: do whatever it does • If <operator> is compound: evaluate body with formal parameters replaced by arguments Lazy…

24. The Difference Normal ((lambda (x) (+ x x)) (* 3 4)) (+ (* 3 4) (* 3 4)) (+ 12 12) 24 Applicative ((lambda (x) (+ x x)) (* 3 4)) (+ 12 12) 24 This may matter in some cases: ((lambda (x y) (+ x 2)) 3 (/ 1 0)) Your interperter works in Applicative Order!

25. Another Example (define f (lambda (x) (f x))) (define g (lambda (x) 5)) (g (f 0)) What will happen with applicative evaluation? What about Normal?

26. LET Revisited (define f (λ (x y) (let ((f-helper (lambda (a b) (+ (* x (* a a)) (* y b) (* a b))) ) ) (f-helper (+ 1 (* x y)) (- 1 y)))))

27. LET and Recursive Procedures (define fact (λ (n) (let ((iter (lambda (prod c) (if (> c n) prod (iter (* c prod) (+ c 1)))) )) (iter 1 1))))

28. LETREC “For local recursive functions there is a special operator letrec, similar to let, and used only for local procedure (function) definitions. It’s syntax is the same as that of let. But, the scope of the local procedure declarations includes all of the initialization procedures!”

29. LETREC (define fact (λ (n) (letrec ((iter (lambda (prod c) (if (> c n) prod (iter (* c prod) (+ c 1)))) )) (iter 1 1))))

30. Usage Agreement • let: non-procedure locals • letrec: procedural locals • The substitution model does not account for local recursive procedures

31. Haskell Curry

32. Currying ;Type: [Number*Number -> Number] (define add (λ (x y) (+ x y))) ;Type: [Number -> [Number -> Number]] (define c-add (λ (x) (λ (y) (add x y)))) (define add3 (c-add 3)) (add3 4) 7

33. Why Currying? (define add-fib (lambda (x y) (+ (fib x) y))) (define c-add-fib (lambda (x) (lambda (y) (+ (fib x) y)))) (define c-add-fib (lambda (x) (let ((fib-x (fib x))) (lambda (y) (+ fib-x y)))))