0) On board announcements: none!

1) Introduction, 5 minutes, 10:05 - 10:10

   Quotation
   Symbolic Processing
   Trees
   Abstraction (again!)

2) Symbols as Data, 10 minutes, 10:10 - 10:20

   a) So far we've had numbers, procedures, and glue
BOARD:
      Draw box and pointer of (2 3 4)
   b) That's like arithmetic, but we'd like to move to algebra: the
      leap from numbers to symbols 
   c) We need to have a representation, both printed and in the
      computer
   d) We pick something that looks like Scheme: (X + 3)
BOARD:
      Draw box and pointer with three slots, fill in the 3, but leave
      the others empty
   e) What goes in the first and second box?  We want things that
      print out + and X (not #[procedure ...] or 10)
   f) Introduce the symbol as an object with identity but nothing else
      -- an abstract data type with one operator, EQ?
   g) How do we create symbols?  Introduce QUOTE on symbols.

3) Symbols vs Strings vs Variables, 2 minutes, 10:20 - 10:22
SLIDE 1:
   (define x (list + '+ "+"))
   x ==> (#[procedure +] + "+") ;;; Also Box & Pointer
   ((car x) 2 3) ==> 5
   (eq? (second x) '+) ==> #T
   (eq? (third x) "+") ==> #F
   (eq? (third x) '+) ==> #F

4) Expressions as Trees, 3 minutes, 10:22 - 10:25

Use numbers to represent numbers,
    symbols to represent variables

SLIDE 2:
   (define (make-binop op left right)
     (list left op right))
   (define (binop? expression) (pair? expression))
   (define (binop.left binop) (first binop))
   (define (binop.op binop) (second binop))
   (define (binop.right binop) (third binop))

   (define expr:5+10 (make-binop '+ 5 10))
BOARD: box & pointer
SLIDE 3:
   expr:5+10                         ; ==> (5 + 10)
   (define expr:3+7*5 (make-binop '* (make-binop '+ 3 7) 5))
   expr:3+7*5                        ; ==> ((3 + 7) * 5)
   (define expr:x+10 (make-binop '+ 'x 10))
   expr:x+10                         ; ==> (x + 10)
   (define expr:x+7*y (make-binop '* (make-binop '+ 'x 7) 'y))
   expr:x+7*y                        ; ==> ((x + 7) * y)

4) Example: symbolic expression evaluator, 5 minutes, 10:25 - 10:30

   a) 3 kinds of expressions: numbers, variables, binary operations
   b) We'll have a dictionary of variable values
   c) We'll use abstract syntax for binary operations
   d) note that operands are expressions that need to be evaluated
   e) Wishful thinking for variables

SLIDE 4:
   (define (expression expr)
     (cond ((number? expr) expr)
           ((symbol? expr) (variable.value expr))
           ((binop? expr)
            (let ((op (binop.op expr))
                  (rand-1 (expression (binop.left expr)))
                  (rand-2 (expression (binop.right expr))))
              (cond ((eq? op '+)
                     (+ rand-1 rand-2))
                    ((eq? op '*)
                     (* rand-1 rand-2))
                    (else (error "Bad operator" expr)))))
           (else (error "Bad expression" expr))))

5) Abstract syntax: Scheme, 5 minutes, 10:30 - 10:35
SLIDE 5:
(define (make-binop op left right)
  (list op left right))
(define (binop? expression) (pair? expression))
(define (binop.left binop) (second binop))
(define (binop.op binop) (first binop))
(define (binop.right binop) (third binop))

(make-binop '+ 5 10))
BOARD: Box & Pointer
    ; ==> (+ 5 10)
(make-binop '* (make-binop '+ 3 7) 5)) ; ==> (* (+ 3 7) 5)

6) Variable lookup, 5 minutes, 10:35 - 10:40

   (define variables
     (list (cons 'X 3)
           (cons 'Y 5)))
SLIDE 6:
   (define (assq name a-list)
     ;; A-List looks like ((name1 ...) (name2 ...) ...)
     (cond ((null? a-list) #F)
           ((eq? name (first (car a-list)))
            (car a-list))
           (else (assq name (cdr a-list)))))

   (define (variable.value name)
     (let ((entry (assq name variables)))
       (if entry
           (cdr entry)
           (error "No such variable" name))))

   (expression number:3)                    ; 3
   (expression variable:x)                  ; 3
   (expression expr:5+10)                   ; 15
   (expression expr:3+7*5)                  ; 50
   (expression expr:x+10)                   ; 13
   (expression expr:x+7*y)                  ; 50

7) Operator lookup using ASSQ, 5 minutes, 10:40 - 10:45
SLIDE 8:
   (define (expression2 expr)
     (define operators
       (list (cons '+ +)
             (cons '* *)))
     (cond ((number? expr) expr)
           ((symbol? expr) (variable.value expr))
           ((list? expr)
            (let ((op (binop.op expr))
                  (rand-1 (expression (binop.left expr)))
                  (rand-2 (expression (binop.right expr))))
              (let ((procedure (assq op operators)))
                (if procedure
                    ((cdr procedure) rand-1 rand-2)
                    (error "Bad operator" expr)))))
           (else (error "Bad expression" expr))))

8) Are operators variables?, 5 minutes, 10:45 - 10:50
SLIDE 9:
   (define variables
     (list (cons 'X 3)
           (cons 'Y 5)
           (cons '+ +)
           (cons '* *)))

   (define (expression3 expr)
     (cond ((number? expr) expr)
           ((symbol? expr) (variable.value expr))
           ((list? expr)
            (let ((op (binop.op expr))
                  (rand-1 (expression (binop.left expr)))
                  (rand-2 (expression (binop.right expr))))
              (let ((procedure (variable.value op)))
                (procedure rand-1 rand-2))))
           (else (error "Bad expression" expr))))

9) Review, which is better?, 5 minutes, 10:50 - 10:55
SLIDE 10:
   (define (make-var name value)
     (cons name value))
   (define (var.name var) (car var))
   (define (var.value var) (cdr var))

   (define (variable.value var)
     (define (loop vars)
       (if (null? vars)
           (error "Undefined variable" var)
           (let ((first-var (first vars)))
             (if (eq? var (var.name first-var))
                 (var.value first-var)
                 (loop (cdr vars))))))
     (loop variables))

   (define (variable.value name)
     (let ((entry (assq name variables)))
       (if entry
           (cdr entry)
           (error "No such variable" name))))

   Quotation
   Symbolic Processing
   Trees
   Data Abstraction -- Plusses and Minusses