anchor.diff:      :class :class-name)
     "HTML attributes that differ from JSX or that need some doctoring to work with Parenscript")
   
  +(defparameter *spread-prop-symbol*
  +  ':&...)
  +
   (defun psx-atom-p (form)
     "Is value atomic--i.e. non-traversable."
     (not (and (listp form)
   	    (keywordp (first form)))))
   
  +(defun spread-prop-symbol-p (object)
  +  (eql *spread-prop-symbol* object))
  +
   (defun parse-prop (prop value)
     (let ((jsx-prop (or (getf *prop-synonyms* prop) prop)))
       (when (or (not (find jsx-prop *binary-props*)) value)
  -      (list (make-symbol (string jsx-prop))
  +      (list (intern (string jsx-prop) :keyword)
   	    value))))
   
   (defun parse-props (form)
  -  (loop
  -     with prop-key = nil
  -     for rest-form on form
  -     for token = (first rest-form)
  -     until (and (not (keywordp token))
  -		(null prop-key))
  -     if prop-key
  -     append (parse-prop prop-key token) into props and
  -     do (setf prop-key nil)
  -     else
  -     do (setf prop-key token)
  -     finally (return (values props rest-form))))
  -
  +  (flet ((prop-key-p (token)
  +	   (or (spread-prop-symbol-p token)
  +	       (keywordp token))))
  +    (loop
  +       with prop-key = nil
  +       for rest-form on form
  +       for token = (first rest-form)
  +       until (and (not (prop-key-p token))
  +		  (null prop-key))
  +       if prop-key
  +         append (parse-prop prop-key token) into props and
  +         do (setf prop-key nil)
  +       else
  +         do (setf prop-key token)
  +       finally (return (values props rest-form)))))
   
   (defun parse-node (node)
     (if (psx-atom-p node)
  
positive.code: (defun dom-type-p (type)
    (find type *dom-types*))
  
  (defun spread-props (proplist)
    (labels ((proc (props obj objs)
               (if (null props)
                   (if obj
                       (nreverse (cons (cons 'ps:create (nreverse obj)) objs))
                       (nreverse objs))
                   ;;FIXME: string-equal is inefficient
                   (if (string-equal (car props) "...")
                       (proc (cddr props)
                             nil
                             (if obj
                                 (list* (second props)
                                        (cons 'ps:create (nreverse obj))
                                        objs)
                                 (cons (second props) objs)))
                       (proc (cddr props)
                             (list* (second props) (first props) obj)
                             objs)))))
      (let ((objs (proc proplist nil nil)))
        (if objs
            `(apply #'react:merge-objects (list ,@objs))
            '(nil)))))
  
  (defun compile-node (parsed-node)
    (if (psx-atom-p parsed-node)
        parsed-node
  
negative.code: 	(let ((type-sym (make-symbol (string type)))
  	      (props-form (cond ((and (null children) (null props)) nil)
  				((null props) (list nil))
  				(t `(,(compile-props props)))))
  	      (children-form (cond ((null children) nil)
  				   ((rest children) (list (list 'array)))
  				   (t (list nil)))))
  