CSC151 2007S, Class 52: Metaprogramming

Admin:
* Due: Exam 3
* No reading for Monday.
* EC for tonight's concert at 7:30.
* I'm a bit disappointed at the 2 a.m. questions.
* So ... 
  * Why did 23 people pre-enroll in my section of 151?
  * Why did only 6 people pre-enroll in 152?

Overview:
* Code vs. Data in Scheme.
* Rewriting Named let structures.
* Generating Code for Objects.

/Code vs. Data/

* What is (f 2 3)
  * The application of f to the values 2 and 3
  * A list of three elements, f, 2, and 3
* An interesting feature of Scheme - code and data look the same
  * The interpretation depends on the context
* Why is it useful to be able to switch between the representations?
  * General benefit of read: We can read 'entire things' (lists, including
    compound lists)
  * General benefit of read: If it's something that Scheme recognizes,
    we don't have to worry about figuring out what it is
  * Once you read a value, you can do different things with it
    "cut and paste", perhaps run it
* You can (easily) write programs that manipulate the source code of other
  programs
  * Read
  * Modify
  * Write 

/Named Lets/

(let proc ((param<sub>1</sub> init<sub>1</sub>)
           (param<sub>2</sub> init<sub>2</sub>)
           ...
           (param<sub>n</sub> init<sub>n</sub>))
  body<sub>1</sub>
  ...
  body<sub>m</sub>)

Vs.

(letrec ((proc
           (lambda (param<sub>1</sub> ... param<sub>n</sub>)
              body<sub>1</sub>
              ...
              body<sub>m</sub>)))
  (proc init<sub>1</sub> ... init<sub>n</sub>))
  
* A named let is a list
  * car of the list is the symbol let
  * cadr of the list is the procedure name, which is a symbol
  * caddr list of two element lists
    * car of each of those is a symbol
    * cadr of each is an expression
  * rest (cdddr) of the named let is a list of expressions, the body

* To convert to the letrec form

(define tmp (read-one-value "writenumbers.scm"))
(define proc (cadr tmp))
(define params (caddr tmp))
(define body (cdddr tmp))

(define make-letrec
  (lambda (proc params body)
    (list 'letrec
          (list (list proc
                      (cons 'lambda (cons (map car params) body))))
          (cons proc (map cadr params)))))

/Generating Code/

* Observation: Objects have a lot of very similar code
  (define make-object
    (lambda ()
      (let ((field1 (vector _))
            (field2 (vector _))
            ...)
        (lambda (method . params)
          (cond
            ...)))))

  (define make-maker
    (lambda (object fields methods)
      (list 'define (string->symbol 
                      (string-append "make-" (symbol->string object)))
            (list 'let
                  (list null)
                  (list 'lambda (cons 'method 'params)
                     (list 'cond
                       ))))))