anchor.diff:    (let ((old* *))
       (lambda xs (foldl old* 1 xs))))
   
  -(define fact
  - (lambda (n)
  +;;; Basic tests
  +(define (fact n)
      (if (< n 2)
          1
  -     (* n (fact (- n 1))))))
  +     (* n (fact (- n 1)))))
  +
  +(define (fib n)
  +  (if (> 1 n)
  +    1
  +    (+ (fib (- n 1)) (fib (- n 2))))) 
  
positive.code:       (proc (car list)
              (foldr proc init (cdr list)))
        init))
  
  (define (list . items)
    (foldr cons nil items))
  
  (define (reverse list)
    (foldl (lambda (a x) (cons x a)) nil list))
  
  (define (unary-map proc list)
    (foldr (lambda (x rest) (cons (proc x) rest))
  
negative.code:     (car list)
      (nth (- pos 1) (cdr list))))
  
  (define (caar x)  (car (car x)))
  (define (caaar x) (car (car (car x))))
  (define (cadr x)  (car (cdr x)))
  (define (caadr x) (car (car (cdr x))))
  (define (cdar x)  (cdr (car x)))
  (define (cddar x) (cdr (cdr (car x))))
  (define (cddr x)  (cdr (cdr x)))
  (define (cdddr x) (cdr (cdr (cdr x))))
  
  (define (macro-expand expr)
    (if (not (pair? expr))
  