anchor.diff:  
   
   (defun compile-node (parsed-node)
  -  (if (atom parsed-node)
  -      parsed-node
  +  (if (descend-p parsed-node)
         (destructuring-bind (&key type props children) parsed-node
           (let ((type-sym
                   (make-symbol (string type)))
  
positive.code:            (if (dom-type-p type)
                 `(ps:chain React DOM (,type-sym ,@props-obj))
                 `(ps:chain React (create-element ,type-sym ,@props-obj)))
             children)))))
  
  
  (defun compile-tree (parsed-tree)
  
negative.code:     (when (or (not (find jsx-attr *binary-attrs*)) value)
    (list (make-symbol (string jsx-attr)) value))))
  
  (defun descend-p (node)
    "Should psx macro parse below this node?"
    (and (listp node) (not (eq (car node) 'ps:ps))))
  
  (defun parse-node (node)
    (let (done attr props)
      (if (descend-p node)
          (do* ((tokens (rest node) (funcall (if done #'identity #'rest) tokens))
                (token (first tokens) (first tokens)))
               ((or done (null tokens))
                (list :type (first node) :props props :children tokens))
            (cond
              (attr
               (setf props (append (parse-attr attr token) props)
                     attr nil))
              ((keywordp token)
               (setf attr token))
              (t
               (setf done t))))
          node)))
  
  
  (defun traverse-tree (function tree)
  