Presentation on theme: "1 Programming Languages (CS 550) Operational Semantics of Scheme using Substitution and the Lambda Calculus Jeremy R. Johnson TexPoint fonts used in EMF."— Presentation transcript:
1 Programming Languages (CS 550) Operational Semantics of Scheme using Substitution and the Lambda Calculus Jeremy R. Johnson TexPoint fonts used in EMF. Read the TexPoint manual before you delete this box.: AAA A A A
2 Starting Point Informal Scheme Semantics To evaluate (E1 E2... En), recursively evaluate E1, E2,...,En - E1 should evaluate to a function - and then apply the function value of E1 to the arguments given by the values of E2,...,En. In the base case, there are self evaluating expressions (e.g. numbers and symbols). In addition, various special forms such as quote and if must be handled separately.
3 Theme This lecture continues our exploration of the semantics of scheme programs. Previously we informally discussed the substitution model, environments, and provided an interpreter for scheme that operationally defined the semantics of scheme programs. In this lecture we will more formally study the substitution model using the lambda calculus. We will also look at alternative (lazy) semantics for scheme and an implementation of streams.
4 Lambda Calculus The semantics of a pure functional programming language can be mathematically described by a substitution process that mimics our understanding of function application - i.e., substitute all occurrences of the formal parameters of a function in the function body by the arguments in the function call. In order to formally study function definition and application and computability, logicians (Alonzo Church, Stephen Cole Kleene, and others) in the 1930s developed a formal notation called the lambda calculus and rules defining an equivalence relation on lambda expressions that encodes function definition and application. They showed the universality of the lambda calculus, the uniqueness of normal forms, and the undecidablity of the equivalence of lambda expressions.
5 Outline Review substitution model of computation Review shortcomings of substitution model Review streams and delayed evaluation Adding support for streams Interpreter with lazy semantics Lambda calculus Free and bound variables alpha and beta reduction Universality of lambda calculus
6 Substitution Model of Computation function application corresponds to substituting the argument expressions into the formal parameters of the function body Order of evaluation Applicative vs. normal order lambda calculus Church-Rosser
8 Order Matters (define (p) (p)) (define (test x y) (if (= x 0) 0 y)) (test 0 (p))
9 Environments When assignment is introduced the substitution model falls apart and a different model, more complicated model, must be used. Environments used to store variables and bindings. Values can change assignment supported List of frames to support nested scope
10 Cost of Assignment (define (make-simplified-withdraw balance) (lambda (amount) (set! balance (- balance amount)) balance)) (define W (make-simplified-withdraw 25)) (W 10) 15 (W 10) 5 (define (make-decrementer balance) (lambda (amount) (- balance amount))) (define D (make-decrementer 25)) (D 10) 15 (D 10) 15
12 Environment Model Solves Problem (define W1 (make-withdraw 100)) (W1 50) (define W2 (make-withdraw 100)) Global Env Balance = 50Balance = 100 E1 E2 Parameters body W1W2 Make-withdraw
13 Scheme Interpreter 1.To evaluate a combination (a compound expression other than a special form), evaluate the subexpressions and then apply the value of the operator subexpression to the values of the operand subexpressions. 2.To apply a compound procedure to a set of arguments, evaluate the body of the procedure in a new environment. To construct this environment, extend the environment part of the procedure object by a frame in which the formal parameters of the procedure are bound to the arguments to which the procedure is applied.
16 Streams Sequence of elements (cons-stream x y) (stream-car s) (stream-cdr s) (stream-null? s) the-empty-stream
17 Streams are Not Lists Consider the following example (car (cdr (filter prime? (enumerate-interval )))) This would be extremely inefficient if implemented with lists Do not build the entire stream of elements Get the next element from the stream when needed Necessary for potentially infinite streams
19 Stream Practice Exercises Complete the trace of (stream-car (stream-cdr (stream-filter prime? (stream-enumerate-interval )))) Modify the scheme interpreter from SICP to support force, delay and streams. You should implement everything needed to execute the above computation.
21 Scheme Interpreter with Streams ;*** The following need to be defined in the metacircular evaluator to ;*** complete the implementation of streams. (define (force delayed-object) (delayed-object) (define (stream-car stream) (car stream)) (define (stream-cdr stream) (force (cdr stream))) (define (stream-null? stream) (null? stream))
22 Lazy Evaluation Language with normal order semantics. Compound procedures are non-strict, while primitive procedures remain strict. Procedure strict if arg evaluated before entering Procedure non-strict if proc not evaluated before entering Delaying evaluation until last possible moment is called lazy evaluation. Delay evaluation of arguments by converting them to thunks. A thunk is forced only when its value is needed. Memoize thunks to avoid repeated evaluation.
23 Examples of Lazy Evaluation (define (try a b) (if (= a 0) 1 b)) (try 0 (/ 1 0)) (define (unless condition usual-value exceptional-value) (if condition exceptional-value usual-value)) (unless (= b 0) (/ a b) (begin (display "exception: returning 0") 0))
32 Streams for Free Previous implementation of streams required new special forms delay and cons-stream and the reimplementation of list functions for streams. In the lazy evaluator lists and streams are identical! Just need to make sure that cons is non-strict Reimplement cons primitive Or implement cons, car, and cdr as functions (see lambda calculus)
33 Lambda Calculus Expressions 1. → variable 2.application: → ( ) 3.abstraction: → (lambda variable. ) Use currying to allow more than one parameter
34 Free and Bound Variables The parameter of an abstraction is bound in the lambda body (lambda (x) E) Variables not bound by a lambda are free
35 Lambda Calculus Reductions 1.beta conversion: ((lambda x.E) F) is equivalent to E[F/x], where F is substituted for all free occurrences of the variable x in E, provided all free variables in F remain free when substituted for x in E. 2.alpha conversion: (lambda x.E) is equivalent to (lambda y,E[y/x]) provided y does not appear free in E and y is not bound by a lambda when substituted for x in E.
36 Example Beta reduction 1.((lambda (x) (lambda (y) (+ x y))) z) 2. (lambda (y) (+ z y)) 3.((lambda (x) (lambda (y) (+ x y))) y) 4. (lambda (y) (+ y y)) [name capture] 4 is not equivalent to 2 [invalid beta reduction] Alpha conversion 1.(lambda (y) (+ x y)) 2. (lambda (z) (+ x z)) 3. (lambda (x) (+ x x)) [name capture]
37 Universality of Lambda Calculus 1.Church numerals and arithmetic using lambda calculus 2.boolean logic, predicates, and conditional statements using lambda calculus 3.Data structures (lists, cons, car, cdr) using lambda calculus 4. Recursion using lambda calculus
38 Y Combinator (define fact (lambda (n) (if (= n 0) 1 (* n (fact (- n 1)))))) 1.(define Y (lambda (g) ((lambda (x) (g (x x))) (lambda (x) (g (x x)))))) 2.(g (Y g)) = (Y g) [fixed point] 3.(define g (lambda (f n) (if (= n 0) 1 (* n (f (- n 1)))))) 4.(g (Y g) n)
39 Lambda Calculus Practice Exc. 0 Given the functions (define (sumf f n) (if (= n 0) 0 (+ (f n) (sumf f (- n 1))))) (define (nth-power n) (lambda (x) (power x n))) evaluate (sumf (nth-power 3) 2) using the substitution model of function evaluation.
40 Lambda Calculus Practice Exc. 1 Implement a scheme function (FV exp), which returns a list of the free variables in the scheme expression exp. The scheme expression will not have let, letrec, or let* statements - the only bindings come from labda expressions.
41 Lambda Calculus Practice Exc. 2 Show that the and, or, and not functions using the lambda calculus in lecture 2b are correct by showing that the correct result is obtained for all combinations of the inputs.
42 Lambda Calculus Practice Exc. 3 Using beta-reduction show that (succ two) is three, where two and three are the Church encodings the numbers 2 and 3 Use induction to prove that ((cn add1) 0) = the number n, where cn is the Church encoding of n. You may assume that add1 correctly adds 1 to its input.
43 Lambda Calculus Practice Exc. 4 Assume that m and n are the encodings of the numbers 2 and 3 as Church numerals. Using the substitution model of computation to show that (mulc2 m n) returns the Church encoding of product m * n = 6. You may assume that (addc a b) returns the Church numeral representing the sum a+b, where inputs a and b are Church encodings for numbers a and b. (define mulc2 (lambda (m n) ((m (lambda (a) (addc n a))) zero)))
44 Lambda Calculus Practice Exc. 5 Trace through the expansion (use beta reduction) of (g (Y g) 3) using the functions g and Y from the discussion on the Y combinator. Try implementing g and Y and computing (g (Y g) 3) in scheme. What happens and why? Try this again using the normal order scheme interpreter in Section of SICP.
45 Lambda Calculus Practice Exc. 6 Implement a scheme function that performs a beta reduction. You must also have a predicate which checks to see if the beta reduction is valid (i.e. the substitution does not cause problems with name collisions)