CS 152 - Lecture 15

Cover page image

Review

Parentheses syntax

(+ 1 2)
(define (fac n) (if (= n 0) 1 (* n (fac (- n 1)))))

Anonymous functions

(map (λ (x) (* x x)) '(1 2 3))  ; (1 4 9)

Let expressions
```
(let ([x 1] [y 2]) (+ x y))
```

Lists: first, rest, cons, empty, empty?

(define (sum lst)
  (if (empty? lst) 
    0 
    (+ (first lst) (sum (rest lst)))))

Apply and Eval

Apply an arbitrary function to a list of arguments

(define circles (map circle '(10 20 30))) ; A list (c1 c2 c3)
(apply hc-append circles) ; Same as calling (hc-append c1 c2 c3)

Evaluate an arbitrary expression

(define expr '(+ 3 4)) ; expr is a list of three items
(eval expr) ; Evaluates expression in list—result is 7

Can generate arbitrary code and execute it later.

(define (fac n) (apply * (range 1 n)))
(define (fac n) (eval (cons '* (range 1 n))))

Here range is

(define (range from to) 
  (if (> from to) empty 
      (cons from (range (+ from 1) to))))

Defining eval/apply in Scheme

We can define eval in Scheme
Gives precise formulation of language semantics
Allows to study implementation of language dialects
“Meta-circular interpreter”—eval can evaluate itself
See the “Wizard book”
Abelson and Sussman, Structure and Interpretation of Computer Programs, MIT Press, 1993. Free book at http://mitpress.mit.edu/sicp

Responsibilities of eval and apply

eval and apply call each other
(eval exp env)
- evaluates all terms of an expression in a given environment
- applies the first term (which must be a procedure) to the others
(apply proc args)
- constructs an environment from the procedure's environment and the parameters
- evaluates all expressions of the procedure's body in that environment

eval

(define (eval exp env) ; env contains bindings of names to values
  (cond ((self-evaluating? exp) exp)
        ((variable? exp) (lookup-variable-value exp env))
        ((quoted? exp) (text-of-quotation exp))
        ((assignment? exp) (eval-assignment exp env))
        ((definition? exp) (eval-definition exp env))
        ((if? exp) (eval-if exp env))
        ((lambda? exp)
         (make-procedure (lambda-parameters exp)
                         (lambda-body exp)
                         env))
        ((begin? exp) 
         (eval-sequence (begin-actions exp) env))
        ((cond? exp) (eval (cond->if exp) env))
        ((application? exp)
         (apply (eval (operator exp) env)
                (list-of-values (operands exp) env)))
        (else
         (error "Unknown expression type -- EVAL" exp))))

apply

(define (apply procedure arguments)
  (cond ((primitive-procedure? procedure)
         (apply-primitive-procedure procedure arguments))
        ((compound-procedure? procedure)
         (eval-sequence
           (procedure-body procedure)
           (extend-environment
             (procedure-parameters procedure)
             arguments
             (procedure-environment procedure))))
        (else
         (error
          "Unknown procedure type -- APPLY" procedure))))

Limits of Computation

Programs that can interpret themselves are important for reasoning about the limits of computation
Turing's Halting Problem
It is not possible to write a program that checks whether a program will terminate on all inputs
Suppose it was possible to write (halt-checker '(lambda (x) expr)) in Scheme
- returns #t if (expr x) halts for all x

Now consider this function (let's call it k)

(lambda (x) (if (halt-checker x) 
  (letrec ([loop (lambda () (loop))]) (loop)) 
  #t))

What is (k k)?

Macros

Easy to write Scheme code that generates Scheme code
Would like to write code that consumes Scheme code
- before it is evaluated
- Example: Make our own while statement
```
(while (> x 0) do (print x) (newline) (set! x (- x 1)))
```

Can do it with closures, but that's not so pretty

(while-do (λ () (> x 0)) (λ () (print x) (newline) (set! x (- x 1))))

Macros are processed before evaluation
```
(define-syntax while ...)
```

A Swap Macro

(define-syntax swap!
    (syntax-rules () ; No keywords—we'll see those later
        (
          (swap! a b) ; Match this pattern
          (let ((c a)) ; Replace with this code
            (set! a b)
            (set! b c))
        )
        ; Other (pattern, code) pairs can come here, e.g. (swap! a b c)
))

Try it out

(define u 1) (define v 2)
(swap! u v) ; Now u is 2, v is 1

“hygienic”—works even if we call (swap! x c)

Keywords and Varargs

(define-syntax while
    (syntax-rules (do) ; do is a keyword
      ((while condition do body ...) ; body is a sequence of terms
       (letrec ([loop (lambda ()
                        (if condition
                            (let ()
                              body ...
                              (loop))
                            #f))]) (loop)))))

Recursive Definitions

 (define-syntax reverse 
    (syntax-rules ()
      ; First case terminates recursion 
      ((reverse e) (list e)) ; or (cons e nil)—(e) would try to evaluate e
      ; Second case invokes macro recursively
      ((reverse e es ...) (append (reverse es ...) (list e)))))

Try it out:
```
(reverse 1 2 3 4) ; yields '(4 3 2 1)
```
Just a silly example, but the same technique can be used to implement let* and others as macros
Details get complex quickly

Macros in Other Languages

C has a preprocessor.

#define SWAP(x, y) { auto temp = x; x = y; y = temp; }

What does SWAP(a[i++], b) do? And SWAP(temp, temp2)?
Scala/Groovy has macros that transform parse trees.
Example: assert in ScalaTest
Very complex to implement

Lab

Step 1 - An Enhanced `for` Loop

In this step, we want to make a macro for a Java-style loop over the elements of a list, like this:

(for i in '(1 2 3 4 5) do (print i) (newline))

What Scheme code should the macro generate? (Hint: map)
Write down the exact code you want to generate for this example.
The variable i in the for statement was not declared previously, and that's how we like it. Where does it get defined? (Hint: Look at the lambda that the map gets.)
What are the keywords of your macro?
What pattern do you match?
What is your macro?
Exactly what gets printed when you run the for statement above? Is there something you can/should do to improve that?
How can you make the do optional?
Your for macro can loop over any list. Make a different macro repeat that repeats the given actions a given number of times, such as
```
(repeat 10 (print "Hello") (newline))
```

Step 2 - Code Generation

In this step, we will write Scheme code that reads and writes Scheme expressions such as the following:

(define poly '(lambda (x) (+ (* x x) (* x 2) 10))) ; Note the quote

What is the type of the value to which poly is set?
How do you compute the value of this polynomial when x is -1?
Now we want to compute derivatives of such polynomials. We'll assume that each * has only two arguments, and that the expression contains only + and * as operators.
Write a helper function (deriv expr var) that computes the derivative with respect to the given variable. For example,
```
(deriv '(+ (* t t) (* t 2)) 't) 
  ; yields '(+ (+ (* 1 t) (* t 1)) (+ (* 1 2) (* t 0)))  ; maybe in a different order
```
What is the code of your helper function?
Now write a function derivative, so that
```
(derivative poly)
```
is a list of the form (lambda (var) ...)

What is the code of your function?
Now give the values of the derivative for x = -20 ... 20 (Hint: range from the slides and map)
What expression do you use?