anchor.diff:  
   (defun expand-macros (exp)
      (if (and (listp exp) (symbol? (car exp)))
  -       (or (when (gethash (string (car exp)) destr-match-clauses)
  -                 (print `(clause ,exp)) 
  +       (or (when (gethash (string (car exp)) destr-match-clauses) 
                    (if (member (car exp) '(test key) :test #'symbol-eq) 
                        (list (first exp) (expand-macros (second exp)) (third exp)) 
                        (cons (car exp) (mapcar #'expand-macros (cdr exp)))))
              (multiple-value-bind (a b) (macroexpand-1 exp)
  -              (print `(macro ,exp ,b))
                 (when b (expand-macros a)))
              (mapcar #'expand-macros exp))
          (if (symbol? exp) 
  
positive.code:       (otherwise       (error "something went very wrong"))))
  
  (defun generate-match-code (exp end)
     `(when (and list ,(match-test (car exp)))
           ,(if end 't
              `(let ((list (cdr list)))
                     (match ,(cdr exp))))))
  
  (defun generate-atom-code (exp end)
     `(when (and list (equalp ,(car exp) (car list)))
           ,(if end 't
              `(let ((list (cdr list)))
                     (match ,(cdr exp))))))
  
  (defun generate-bind-code (exp end)
     (if end
         `(when list (setf ,(car exp) list) t)
         (with-gensyms (v x w r loop succeed fail end)
           `(let ((,v (list (car list))) (,x (cdr list)) (,w nil) (,r nil))
                  (tagbody
                    ,loop
                       (when (not ,x) (go ,fail))
                       (setf ,w (let ((list ,x)) (match ,(cdr exp))))
                       (when (eq ,w t) (go ,succeed))
                       (appendf ,v (list (car ,x)))
                       (setf ,x (cdr ,x))
                       (go ,loop)
                    ,fail
                       (setf ,(car exp) nil)
                       (setf ,r nil)
                       (go ,end)
                    ,succeed
                       (setf ,(car exp) ,v)
                       (setf ,r ,w)
                    ,end)
                  ,r))))
  
  (defmacro match (exp)
     (let ((end-of-chain? (not (cdr exp))))
  
negative.code: (in-package destr-match)
  
  ;; TODO
  ;; [w] fill out the README with examples and documentation
  ;; [w] sublists
  ;; [ ] modify match so clause names without arguments are bindings
  ;; [?] full literal value matching, using quotes for symbols
  ;; [w] fix indentation and maybe line length
  ;; [w] single/multiple modes
  ;; [w] 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
  
  (defparameter destr-match-clauses (make-hash-table :test #'equalp))
  (defparameter matching-style 'symbol) ;; symbol, string, case-sensitive, regex, symbol-regex
  (defparameter single-mode t)
  
  (defmacro def-match-clause (name ll &rest rest)
     `(setf (gethash ,(string name) destr-match-clauses) (lambda ,ll ,@rest)))
  