anchor.diff:                      (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)))))
  +   (bind-single (car var) rest 'normal))
   
   (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)))))
  +       (bind-single (second (first var)) rest 'test (second var))
  +       (if end
  +          `(when (and list (funcall ,(second var) list)) (setf ,(first var) list) t)
  +           (generate-bind-body (car var) rest 'test (second var)))))
   
   (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)))))
  +       (bind-single (second (first var)) rest 'test (second var))
  +       (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))
  
positive.code:        (generate-bind-body (car exp) (cdr exp) 'normal)))
  
  (defmacro match (exp)
     (let ((end-of-chain? (not (cdr exp))))
        (if (listp (car exp))
            (aif (gethash (string (caar exp)) destr-match-clauses)
  
negative.code:            `(let ((list (cdr list)))
                    (match ,(cdr exp))))))
  
  (defun bind-single (sym rest type &optional fun)
    `(when ,(if (eq type 'normal) 
               `(car list) 
               `(and (car list) (funcall ,fun (car list))))
        (setf ,sym (car list))
       ,(if rest 
          `(let ((list (cdr list)))
                 (match ,rest))
          `(not (car list)))))
  
  (defun bind-multiple (sym rest type &optional fun)
     (with-gensyms (x w r f loop succeed fail end)
       `(let ((,x (cdr list)) (,w nil) (,r nil))
              (setf ,sym (list (car list)))
              (tagbody
                ,loop
                    (when (not ,x) (go ,fail))
                    (setf ,w (let ((list ,x)) (match ,rest)))
                   ,(case type
                       (normal `(when (eq ,w t) (go ,succeed)))
                       (test   `(when (and (eq ,w t) (funcall ,fun ,sym)) (go ,succeed)))
                       (key    `(let ((,f (funcall ,fun ,sym)))
                                      (when (and (eq ,w t) ,f)
                                            (setf ,sym ,f) (go ,succeed)))))
                    (appendf ,sym (list (car ,x)))
                    (setf ,x (cdr ,x))
                    (go ,loop)
                ,fail
                    (setf ,sym nil)
                    (setf ,r nil)
                    (go ,end)
                ,succeed
                    (setf ,r ,w)
                ,end)
             ,r)))
  
  ;; here be dragons
  (defun generate-bind-body (sym rest type &optional fun)
     (if single-mode
         (bind-single sym rest type fun)
         (bind-multiple sym rest type fun)))
  
  (defun generate-bind-code (exp end)
     (if end
  