anchor.diff:           (setf exp (first body))
            (setf match-form (second body))
            (setf body (cddr body)))
  -   (when (gethash (string (car match-form)) destr-match-clauses)
  +   (when (and (symbolp (car match-form)) 
  +              (gethash (string (car match-form)) destr-match-clauses))
            (setf match-form (list match-form)))
  +   (print 'foo)
      (multiple-value-bind (match-form bindings) (expand-main match-form)
         `(let ,(append `((list ,exp)) (simple-pair bindings nil))
                (if (match ,match-form)
  
positive.code:                     (if ,foo ,foo (match ,(append `((choice ,@(cdr forms))) rest))))))))
  
  (def-match-clause single (var rest end)
     (if end
         `(progn (setf ,(car var) (car list))
                 (if (not (cdr list))
                     t
                     (cdr list)))
         `(when (car list)
            (setf ,(car var) (car list))
            (let ((list (cdr list)))
                  (match ,rest)))))
  
  (defun test-single (var rest end)
     (if end
        `(when (and (car list) (funcall ,(second var) (car list)))
               (setf ,(second (first var)) (car list))
               (not (cdr list)))
        `(when (and (car list) (funcall ,(second var) (car list)))
               (setf ,(second (first var)) (car list))
               (let ((list (cdr list)))
                     (match ,rest)))))
  
  (def-match-clause test (var rest end)
     (if (and (listp (first var)) (symbol-eq (car (first var)) 'single))
         (test-single var rest end)
     (if end
        `(when (and list (funcall ,(second var) list)) (setf ,(first var) list) t)
         (generate-bind-body (car var) rest 'test (second var)))))
  
  (defun key-single (var rest end)
     (if end
         `(awhen (and (car list) (funcall ,(second var) (car list)))
                 (setf ,(second (first var)) it)
                 (not (cdr list)))
         `(awhen (and (car list) (funcall ,(second var) (car list)))
                 (setf ,(second (first var)) it)
                 (let ((list (cdr list)))
                       (match ,rest)))))
  
  (def-match-clause key (var rest end)
     (if (and (listp (first var)) (symbol-eq (car (first var)) 'single))
        (key-single var rest end)
        (if end
           `(awhen (and list (funcall ,(second var) list)) (setf ,(first var) it) t)
            (generate-bind-body (car var) rest 'key (second var)))))
  
  (defun simple-pair (list val)
     (mapcar (lambda (x) (list x val)) list))
  
negative.code:        (generate-bind-body (car exp) (cdr exp) 'normal)))
  
  (defmacro match (exp)
     (print `(match ,exp))
     (let ((end-of-chain? (not (cdr exp))))
        (if (listp (car exp))
            (aif (gethash (string (caar exp)) destr-match-clauses)
  