anchor.diff:    #`(defparameter (function ,name) (lambda ,sig ,@body)))
   
   (defmacro let (bindings &rest body)
  -  #`(funcall (lambda ,(%compound-map (lambda (b) 
  -                                       (%compound-elt b 0))
  +  #`(funcall (lambda ,(%compound-map (lambda (b)
  +                                       (if (%compound? b)
  +                                           (%compound-elt b 0)
  +                                           b))
                                        bindings)
                  ,@body)
  -              ,@(%compound-map (lambda (b) 
  -                                 (%compound-elt b 1)) 
  -                               bindings)))
  +             ,@(%compound-map (lambda (b) 
  +                                (if (%compound? b)
  +                                    (%compound-elt b 1)
  +                                    #'nil))
  +                              bindings)))
   
   (defmacro let* (bindings &rest forms) ;; Scheme's letrec*
     #`(let ,(%compound-map (lambda (b)
  
positive.code:   (%compound-slice cf start end))
  
  (defun compound? ((a object))
    (%compound? cf))
  
  (defun eq ((a object) (b object))
    (%eq a b))
  
negative.code: (defmacro make (class-name)
    #`(make-instance (class ,class-name)))
  
  (defmacro defclass (class-name &optional (supers #'()) (slot-descriptors #'()))
    (let ((superclass (if (compound-empty? supers) #f (compound-elt supers 0))))
      #`(progn
          (defvar (class ,class-name) (make-class))
  