anchor.diff:  
   (defmacro native-body (&rest stuff)
     #`#{ (function(){ ~,@stuff })() #})
  +
  +;;;; Dynamic variables
  +
  +(defmacro dynamic (name)
  +  #`(identifier ,name dynamic))
  +
  +(defmacro defdynamic (name &optional (value #'nil))
  +  #`(defvar (dynamic ,name) ,value))
  +
  +(defmacro dynamic-bind (bindings &rest body)
  +  (if (compound-empty? bindings)
  +      #`(progn ,@body)
  +      #`(dynamic-bind-1 ,(compound-elt bindings 0)
  +          (dynamic-bind ,(compound-slice bindings 1)
  +             ,@body))))
  +
  +(defmacro dynamic-bind-1 (binding &rest body)
  +  (let ((name (compound-elt binding 0))
  +        (value (compound-elt binding 1)))
  +    #`(let ((old-value (dynamic ,name)))
  +        (setq (dynamic ,name) ,value)
  +        (unwind-protect (progn ,@body)
  +          (setq (dynamic ,name) old-value)))))
   
   ;;;; Object system
   
  
positive.code:           (slot-value obj ,slot-name-form))
          (defmethod ,(string-to-symbol setter-name) ((obj ,class) value)
            (set-slot-value obj ,slot-name-form value)))))
  
  (defgeneric show (object))
  
  (eval-when-compile
    (defun show-unreadable (class-name &optional (more ""))
      (string-concat "#(" (symbol-name class-name) more ")")))
  
  (defmacro define-stupid-show (class-name)
    #`(defmethod show ((a ,class-name))
        ,(string-to-form (show-unreadable class-name))))
  
  ;;;; Fixup class hierarchy
  
  
negative.code: 
  (defmacro decf (place &optional (delta #'1))
    #`(setf ,place (- ,place ,delta)))
  
  ;;;; Stuff
  
  (defun nil? (x)
    (if (eq nil x) #t #f))
  
  (defmacro assert (test &optional (msg #'"assertion failed"))
    #`(let ((result ,test))
  