PPL Syntax & Formal Semantics Lecture Notes: Chapter 2

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

Today Concrete and Abstract Syntax Operational Semantics: applicative order and normal order

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

Concrete Syntax Non-terminals are denoted as Terminals (tokens) are surrounded with ’ Optional items are denoted as [ ] 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

Concrete Syntax -> | ’(’ ’)’ -> | ’(’ ’)’ -> | -> | -> Numbers -> ’#t’ | ’#f’

-> ( ) -> ( if )-> ( if #f ) -> ( if #f number) -> ( if #f 2) -> ( if #f ( ) 2) -> ( if #f ( / ) 2) -> ( if #f ( / 1 ) 2) -> ( if #f ( / 1 0 ) 2) -> | ’(’ ’)’ -> | | -> | -> Numbers -> ’#t’ | ’#f’ -> sequences of letters, digits, punctuation marks -> | | | | -> + -> ’lambda’ ’(’ * ’)’ + -> ’quote’ -> ’cond’ * -> ’(’ + ’)’ -> ’(’ ’else’ + ’)’ -> ’if’ -> ’let’ ’(’ * ’)’ + -> ’(’ ’)’

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

Abstract Syntax : Kinds:, : Kinds:, : Kinds:,, … : Components: Variable: Expression:

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

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

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

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: 1.Scope of lambda parameters is the entire lambda expression (or let body) 2.Scope of define variables is the entire program, from the define expression and on: Universal / global scope

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.

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

Renaming Bound variables can be renamed without changing the semantics (kind like renaming in Java Eclipse) (lambda (x) x) (lambda (y) y)

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

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

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... ( …… ) Evaluate to get the procedure evaluate to get the arguments If is primitive: do whatever magic it does If is compound: evaluate body with formal parameters replaced by arguments Eager!

22 Normal order evaluation Combination … ( …… ) Evaluate to get the procedure evaluate to get the arguments If is primitive: do whatever it does If is compound: evaluate body with formal parameters replaced by arguments Lazy…

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

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?

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

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

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!”

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

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

Haskell Curry

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

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