anchor.diff:         (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)
  
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: ;; [w] sublists
  ;; [ ] modify match so clause names without arguments are bindings
  ;; [?] full literal value matching, using quotes for symbols
  ;; [x] fix indentation and maybe line length
  ;; [w] single/multiple modes
  ;; [x] make the variables update during matching
  ;; [?] scan for free symbols in normal expressions, like (member foo '(bar baz)) 
  ;;       would need some way of detecting already-bound local variables? 
  ;; [?] optimize matching more
  ;; [?] another layer of expansion so you can overload macro names
  ;; [ ] remove this end of chain stuff
  
  (defparameter destr-match-clauses (make-hash-table :test #'equalp))
  (defparameter matching-style 'symbol) ;; symbol, string, case-sensitive, regex, symbol-regex
  (defparameter single-mode nil)
  
  (defmacro def-match-clause (name ll &rest rest)
     `(setf (gethash ,(string name) destr-match-clauses) (lambda ,ll ,@rest)))
  